home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / bin / groffer < prev    next >
Encoding:
Text File  |  2005-10-13  |  111.8 KB  |  4,531 lines
  1. #!/bin/sh
  2.  
  3. # groffer - display groff files
  4.  
  5. # Source file position: <groff-source>/contrib/groffer/groffer.sh
  6.  
  7. # Copyright (C) 2001,2002,2003,2004 Free Software Foundation, Inc.
  8. # Written by Bernd Warken
  9.  
  10. # This file is part of groff version 1.19.1.
  11.  
  12. # groff is free software; you can redistribute it and/or modify it
  13. # under the terms of the GNU General Public License as published by
  14. # the Free Software Foundation; either version 2, or (at your option)
  15. # any later version.
  16.  
  17. # groff is distributed in the hope that it will be useful, but WITHOUT
  18. # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  19. # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  20. # License for more details.
  21.  
  22. # You should have received a copy of the GNU General Public License
  23. # along with groff; see the files COPYING and LICENSE in the top
  24. # directory of the groff source.  If not, write to the Free Software
  25. # Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26.  
  27. _PROGRAM_NAME='groffer';
  28. _PROGRAM_VERSION='0.9.7';
  29. _LAST_UPDATE='30 Apr 2004';
  30.  
  31.  
  32. ########################################################################
  33. # Determine the shell under which to run this script;
  34. # if `ash' is available restart the script using `ash';
  35. # otherwise just go on.
  36.  
  37. if test "${_groffer_run}" = ''; then
  38.   # only reached during the first run of the script
  39.  
  40.   export _PROGRAM_NAME;
  41.   export _PROGRAM_VERSION;
  42.   export _LAST_UPDATE;
  43.  
  44.   export GROFFER_OPT;        # option environment for groffer
  45.   export _GROFFER_SH;        # file name of this shell script
  46.   export _OUTPUT_FILE_NAME;    # output generated, see main_set_res..()
  47.   export _groffer_run;        # counter for the runs of groffer
  48.  
  49.   _groffer_run='first';
  50.  
  51.   case "$0" in
  52.   *${_PROGRAM_NAME}*)
  53.     _GROFFER_SH="$0";
  54.     # was: _GROFFER_SH="/usr/bin/${_PROGRAM_NAME}";
  55.     ;;
  56.   *)
  57.     echo "The ${_PROGRAM_NAME} script should be started directly." >&2
  58.     exit 1;
  59.     ;;
  60.   esac;
  61.  
  62.   ###########################
  63.   # _get_opt_shell ("$@")
  64.   #
  65.   # Determine whether `--shell' was specified in $GROFF_OPT or in $*;
  66.   # if so echo its argument.
  67.   #
  68.   _get_opt_shell()
  69.   {
  70.     local i;
  71.     local _sh;
  72.     case " ${GROFFER_OPT} $*" in
  73.       *\ --shell\ *|*\ --shell=*)
  74.         (
  75.           eval set -- "${GROFFER_OPT}" '"$@"';
  76.           _sh='';
  77.           for i in "$@"; do
  78.             case "$1" in
  79.               --shell)
  80.                 if test "$#" -ge 2; then
  81.                   _sh="$2";
  82.                   shift;
  83.                 fi;
  84.                 ;;
  85.               --shell=?*)
  86.                 # delete up to first `=' character
  87.                 _sh="$(echo -n "$1" | sed -e 's/^[^=]*=//')";
  88.                 ;;
  89.             esac;
  90.             shift;
  91.           done;
  92.           echo -n "${_sh}";
  93.         )
  94.         ;;
  95.     esac;
  96.   }
  97.  
  98.  
  99.   ###########################
  100.   # _test_on_shell (<name>)
  101.   #
  102.   # Test whether <name> is a shell program of Bourne type (POSIX sh).
  103.   #
  104.   _test_on_shell()
  105.   {
  106.     if test "$#" -le 0 || test "$1" = ''; then
  107.       return 1;
  108.     fi;
  109.     # do not quote $1 to allow arguments
  110.     test "$($1 -c 's=ok; echo -n "$s"' 2>/dev/null)" = 'ok';
  111.   }
  112.  
  113.   # do the shell determination
  114.   _shell="$(_get_opt_shell "$@")";
  115.   if test "${_shell}" = ''; then
  116.     _shell='ash';
  117.   fi;
  118.   if _test_on_shell "${_shell}"; then
  119.     _groffer_run='second';
  120.     # do not quote $_shell to allow arguments
  121.     exec ${_shell} "${_GROFFER_SH}" "$@";
  122.     exit;
  123.   fi;
  124.  
  125.   # clean-up of shell determination
  126.   unset _shell;
  127.   unset _GROFFER_SH;
  128.   unset _groffer_run;
  129.   _get_opt_shell()
  130.   {
  131.     return 0;
  132.   }
  133.   _test_on_shell()
  134.   {
  135.     return 0;
  136.   }
  137.  
  138. fi; # end of first run
  139.  
  140. if test "${_groffer_run}" != 'second';
  141. then
  142.   echo "$_groffer_run should be 'second' here." >&2
  143.   exit 1
  144. fi;
  145. unset _groffer_run
  146.  
  147.  
  148. ########################################################################
  149. # diagnostic messages
  150. #
  151. export _DEBUG;
  152. _DEBUG='no';            # disable debugging information
  153. #_DEBUG='yes';            # enable debugging information
  154.  
  155. export _DEBUG_LM;
  156. _DEBUG_LM='no';            # disable landmark messages
  157. #_DEBUG_LM='yes';        # enable landmark messages
  158.  
  159.  
  160. ########################################################################
  161. #                       Environment Variables
  162. ########################################################################
  163.  
  164. # Environment variables that exist only for this file start with an
  165. # underscore letter.  Global variables to this file are written in
  166. # upper case letters, e.g. $_GLOBAL_VARIABLE; temporary variables
  167. # start with an underline and use only lower case letters and
  168. # underlines, e.g.  $_local_variable .
  169.  
  170. #   [A-Z]*     system variables,      e.g. $MANPATH
  171. #   _[A-Z_]*   global file variables, e.g. $_MAN_PATH
  172. #   _[a-z_]*   temporary variables,   e.g. $_manpath
  173.  
  174. # Due to incompatibilities of the `ash' shell, the name of loop
  175. # variables in `for' must be single character
  176. #   [a-z]      local loop variables,   e.g. $i
  177.  
  178.  
  179. ########################################################################
  180. # read-only variables (global to this file)
  181. ########################################################################
  182.  
  183. # characters
  184.  
  185. export _BQUOTE;
  186. export _BSLASH;
  187. export _DQUOTE;
  188. export _NEWLINE;
  189. export _LBRACK;
  190. export _LPAR;
  191. export _RBRACK;
  192. export _RPAR;
  193. export _SPACE;
  194. export _SQUOTE;
  195. export _TAB;
  196.  
  197. _BQUOTE='`';
  198. _BSLASH='\';
  199. _DQUOTE='"';
  200. _NEWLINE='
  201. ';
  202. _LBRACK='[';
  203. _LPAR='(';
  204. _RBRACK=']';
  205. _RPAR=')';
  206. _SPACE=' ';
  207. _SQUOTE="'";
  208. _TAB='    ';
  209.  
  210. # function return values; `0' means ok; other values are error codes
  211. export _ALL_EXIT;
  212. export _BAD;
  213. export _ERROR;
  214. export _GOOD;
  215. export _NO;
  216. export _OK;
  217. export _YES;
  218.  
  219. _GOOD='0';            # return ok
  220. _BAD='1';            # return negatively, error code `1'
  221. _ERROR='7';            # for syntax errors; no `-1' in `ash'
  222.  
  223. _ALL_EXIT="${_GOOD} ${_BAD} ${_ERROR}"; # all exit codes (for `trap_set')
  224.  
  225. _NO="${_BAD}";
  226. _YES="${_GOOD}";
  227. _OK="${_GOOD}";
  228.  
  229. # quasi-functions, call with `eval'
  230. export return_ok;
  231. export return_good;
  232. export return_bad;
  233. export return_yes;
  234. export return_no;
  235. export return_error;
  236. return_ok="func_pop; return ${_OK}";
  237. return_good="func_pop; return ${_GOOD}";
  238. return_bad="func_pop; return ${_BAD}";
  239. return_yes="func_pop; return ${_YES}";
  240. return_no="func_pop; return ${_NO}";
  241. return_error="func_pop; return ${_ERROR}";
  242.  
  243.  
  244. export _CONFFILES;
  245. _CONFFILES="/etc/groff/groffer.conf ${HOME}/.groff/groffer.conf";
  246.  
  247. export _DEFAULT_MODES;
  248. _DEFAULT_MODES='x,ps,tty';
  249. export _DEFAULT_RESOLUTION;
  250. _DEFAULT_RESOLUTION='75';
  251.  
  252. export _DEFAULT_TTY_DEVICE;
  253. _DEFAULT_TTY_DEVICE='latin1';
  254.  
  255. # _VIEWER_* viewer programs for different modes (only X is necessary)
  256. # _VIEWER_* a comma-separated list of viewer programs (with options)
  257. export _VIEWER_DVI;        # viewer program for dvi mode
  258. export _VIEWER_PS;        # viewer program for ps mode
  259. export _VIEWER_HTML_X;        # viewer program for html mode in X
  260. export _VIEWER_HTML_TTY;    # viewer program for html mode in tty
  261. _VIEWER_DVI='xdvi,dvilx';
  262. _VIEWER_PDF='xpdf,acroread';
  263. _VIEWER_PS='gv,ghostview,gs_x11,gs';
  264. _VIEWER_HTML='konqueror,mozilla,netscape,opera,amaya,arena,lynx';
  265. _VIEWER_X='gxditview,xditview';
  266.  
  267. # Search automatically in standard sections `1' to `8', and in the
  268. # traditional sections `9', `n', and `o'.  On many systems, there
  269. # exist even more sections, mostly containing a set of man pages
  270. # special to a specific program package.  These aren't searched for
  271. # automatically, but must be specified on the command line.
  272. export _MAN_AUTO_SEC;
  273. _MAN_AUTO_SEC="'1' '2' '3' '4' '5' '6' '7' '8' '9' 'n' 'o'"
  274.  
  275. export _PROCESS_ID;        # for shutting down the program
  276. _PROCESS_ID="$$";
  277.  
  278.  
  279. ############ the command line options of the involved programs
  280. #
  281. # The naming scheme for the options environment names is
  282. # $_OPTS_<prog>_<length>[_<argspec>]
  283. #
  284. # <prog>:    program name GROFFER, GROFF, or CMDLINE (for all
  285. #            command line options)
  286. # <length>:  LONG (long options) or SHORT (single character options)
  287. # <argspec>: ARG for options with argument, NA for no argument;
  288. #            without _<argspec> both the ones with and without arg.
  289. #
  290. # Each option that takes an argument must be specified with a
  291. # trailing : (colon).
  292.  
  293. # exports
  294. export _OPTS_GROFFER_SHORT_NA;
  295. export _OPTS_GROFFER_SHORT_ARG;
  296. export _OPTS_GROFFER_LONG_NA;
  297. export _OPTS_GROFFER_LONG_ARG;
  298. export _OPTS_GROFF_SHORT_NA;
  299. export _OPTS_GROFF_SHORT_ARG;
  300. export _OPTS_GROFF_LONG_NA;
  301. export _OPTS_GROFF_LONG_ARG;
  302. export _OPTS_X_SHORT_ARG;
  303. export _OPTS_X_SHORT_NA;
  304. export _OPTS_X_LONG_ARG;
  305. export _OPTS_X_LONG_NA;
  306. export _OPTS_MAN_SHORT_ARG;
  307. export _OPTS_MAN_SHORT_NA;
  308. export _OPTS_MAN_LONG_ARG;
  309. export _OPTS_MAN_LONG_NA;
  310. export _OPTS_MANOPT_SHORT_ARG;
  311. export _OPTS_MANOPT_SHORT_NA;
  312. export _OPTS_MANOPT_LONG_ARG;
  313. export _OPTS_MANOPT_LONG_NA;
  314. export _OPTS_CMDLINE_SHORT_NA;
  315. export _OPTS_CMDLINE_SHORT_ARG;
  316. export _OPTS_CMDLINE_LONG_NA;
  317. export _OPTS_CMDLINE_LONG_ARG;
  318.  
  319. ###### groffer native options
  320.  
  321. _OPTS_GROFFER_SHORT_NA="'h' 'Q' 'v' 'V' 'X' 'Z'";
  322. _OPTS_GROFFER_SHORT_ARG="'T'";
  323.  
  324. _OPTS_GROFFER_LONG_NA="'auto' 'debug' 'default' 'dvi' \
  325. 'groff' 'help' 'intermediate-output' 'html' 'man' \
  326. 'no-location' 'no-man' 'pdf' 'ps' 'rv' 'source' 'text' 'text-device' \
  327. 'title' 'tty' 'tty-device' 'version' 'whatis' 'where' 'www' 'x' 'X'";
  328.  
  329. _OPTS_GROFFER_LONG_ARG="\
  330. 'apropos' 'apropos-data' 'apropos-devel' 'apropos-progs' \
  331. 'default-modes' 'dvi-viewer' 'extension' 'fg' 'fn' 'font' \
  332. 'foreground' 'html-viewer' 'mode' 'pdf-viewer' 'ps-viewer' 'shell' \
  333. 'tty-viewer' 'www-viewer' 'x-viewer' 'X-viewer'";
  334.  
  335. ##### groffer options inhereted from groff
  336.  
  337. _OPTS_GROFF_SHORT_NA="'a' 'b' 'c' 'C' 'e' 'E' 'g' 'G' 'i' 'l' 'N' 'p' \
  338. 'R' 's' 'S' 't' 'U' 'V' 'z'";
  339. _OPTS_GROFF_SHORT_ARG="'d' 'f' 'F' 'I' 'L' 'm' 'M' 'n' 'o' 'P' 'r' \
  340. 'w' 'W'";
  341. _OPTS_GROFF_LONG_NA="'source'";
  342. _OPTS_GROFF_LONG_ARG="'device' 'macro-file'";
  343.  
  344. ##### groffer options inhereted from the X Window toolkit
  345.  
  346. _OPTS_X_SHORT_NA="";
  347. _OPTS_X_SHORT_ARG="";
  348.  
  349. _OPTS_X_LONG_NA="'iconic' 'rv'";
  350.  
  351. _OPTS_X_LONG_ARG="'background' 'bd' 'bg' 'bordercolor' 'borderwidth' \
  352. 'bw' 'display' 'fg' 'fn' 'font' 'foreground' 'ft', 'geometry'
  353. 'resolution' 'title' 'xrm'";
  354.  
  355. ###### groffer options inherited from man
  356.  
  357. _OPTS_MAN_SHORT_NA="";
  358. _OPTS_MAN_SHORT_ARG="";
  359.  
  360. _OPTS_MAN_LONG_NA="'all' 'ascii' 'catman' 'debug' 'ditroff' 'help' \
  361. 'local-file' 'location' 'pager' 'troff' 'update' 'version' \
  362. 'whatis' 'where'";
  363.  
  364. _OPTS_MAN_LONG_ARG="'extension' 'locale' 'manpath' \
  365. 'pager' 'preprocessor' 'prompt' 'sections' 'systems' 'troff-device'";
  366.  
  367. ###### additional options for parsing $MANOPT only
  368.  
  369. _OPTS_MANOPT_SHORT_NA="'7' 'a' 'c' 'd' 'D' 'f' 'h' 'k' 'l' 't' 'u' \
  370. 'V' 'w' 'Z'";
  371. _OPTS_MANOPT_SHORT_ARG="'e' 'L' 'm' 'M' 'p' 'P' 'r' 'S' 'T'";
  372.  
  373. _OPTS_MANOPT_LONG_NA="${_OPTS_MAN_LONG_NA} \
  374. 'apropos' 'debug' 'default' 'html' 'ignore-case' 'location-cat' \
  375. 'match-case' 'troff' 'update' 'version' 'where-cat'";
  376.  
  377. _OPTS_MANOPT_LONG_ARG="${_OPTS_MAN_LONG_NA} \
  378. 'config_file' 'encoding' 'locale'";
  379.  
  380. ###### collections of command line options
  381.  
  382. _OPTS_CMDLINE_SHORT_NA="${_OPTS_GROFFER_SHORT_NA}\
  383. ${_OPTS_GROFF_SHORT_NA} ${_OPTS_X_SHORT_NA} ${_OPTS_MAN_SHORT_NA}";
  384. _OPTS_CMDLINE_SHORT_ARG="${_OPTS_GROFFER_SHORT_ARG} \
  385. ${_OPTS_GROFF_SHORT_ARG} ${_OPTS_X_SHORT_ARG} ${_OPTS_MAN_SHORT_ARG}";
  386.  
  387. _OPTS_CMDLINE_LONG_NA="${_OPTS_GROFFER_LONG_NA} \
  388. ${_OPTS_GROFF_LONG_NA} ${_OPTS_X_LONG_NA} ${_OPTS_MAN_LONG_NA}";
  389. _OPTS_CMDLINE_LONG_ARG="${_OPTS_GROFFER_LONG_ARG} \
  390. ${_OPTS_GROFF_LONG_ARG} ${_OPTS_MAN_LONG_ARG} ${_OPTS_X_LONG_ARG}";
  391.  
  392.  
  393. ########################################################################
  394. # read-write variables (global to this file)
  395. ########################################################################
  396.  
  397. export _ADDOPTS_GROFF;        # Transp. options for groff (`eval').
  398. export _ADDOPTS_POST;        # Transp. options postproc (`eval').
  399. export _ADDOPTS_X;        # Transp. options X postproc (`eval').
  400. export _DEFAULT_MODES;        # Set default modes.
  401. export _DISPLAY_MODE;        # Display mode.
  402. export _DISPLAY_PROG;        # Viewer program to be used for display.
  403. export _DISPLAY_ARGS;        # X resources for the viewer program.
  404. export _FILEARGS;        # Stores filespec parameters.
  405. export _FUNC_STACK;        # Store debugging information.
  406. export _REGISTERED_TITLE;    # Processed file names.
  407. # _HAS_* from availability tests
  408. export _HAS_COMPRESSION;    # `yes' if compression is available
  409. export _HAS_OPTS_GNU;        # `yes' if GNU `getopt' is available
  410. export _HAS_OPTS_POSIX;        # `yes' if POSIX `getopts' is available
  411. # _MAN_* finally used configuration of man searching
  412. export _MAN_ALL;        # search all man pages per filespec
  413. export _MAN_ENABLE;        # enable search for man pages
  414. export _MAN_EXT;        # extension for man pages
  415. export _MAN_FORCE;        # force file parameter to be man pages
  416. export _MAN_IS_SETUP;        # setup man variables only once
  417. export _MAN_LANG;        # language for man pages
  418. export _MAN_LANG_DONE;        # language dirs added to man path
  419. export _MAN_PATH;        # search path for man pages
  420. export _MAN_SEC;        # sections for man pages; sep. `:'
  421. export _MAN_SEC_DONE;        # sections added to man path
  422. export _MAN_SYS;        # system names for man pages; sep. `,'
  423. export _MAN_SYS;        # system names added to man path
  424. # _MANOPT_* as parsed from $MANOPT
  425. export _MANOPT_ALL;        # $MANOPT --all
  426. export _MANOPT_EXTENSION;    # $MANOPT --extension
  427. export _MANOPT_LANG;        # $MANOPT --locale
  428. export _MANOPT_PATH;        # $MANOPT --manpath
  429. export _MANOPT_PAGER;        # $MANOPT --pager
  430. export _MANOPT_SEC;        # $MANOPT --sections
  431. export _MANOPT_SYS;        # $MANOPT --systems
  432. # _OPT_* as parsed from groffer command line
  433. export _OPT_ALL;        # display all suitable man pages.
  434. export _OPT_APROPOS;        # call `apropos' program.
  435. export _OPT_APROPOS_DATA;    # `apropos' for man sections 4, 5, 7
  436. export _OPT_APROPOS_DEVEL;    # `apropos' for man sections 2, 3, 9
  437. export _OPT_APROPOS_PROGS;    # `apropos' for man sections 1, 6, 8
  438. export _OPT_BD;            # set border color in some modes.
  439. export _OPT_BG;            # set background color in some modes.
  440. export _OPT_BW;            # set border width in some modes.
  441. export _OPT_DEBUG;        # print debugging information on stderr.
  442. export _OPT_DEFAULT_MODES;    # `,'-list of modes when no mode given.
  443. export _OPT_DEVICE;        # device option.
  444. export _OPT_DISPLAY;        # set X display.
  445. export _OPT_FG;            # set foreground color in some modes.
  446. export _OPT_FN;            # set font in some modes.
  447. export _OPT_GEOMETRY;        # set size and position of viewer in X.
  448. export _OPT_ICONIC;        # -iconic option for X viewers.
  449. export _OPT_LANG;        # set language for man pages
  450. export _OPT_LOCATION;        # print processed file names to stderr
  451. export _OPT_MODE;        # values: X, tty, Q, Z, ""
  452. export _OPT_MANPATH;        # manual setting of path for man-pages
  453. export _OPT_PAGER;        # specify paging program for tty mode
  454. export _OPT_RESOLUTION;        # set X resolution in dpi
  455. export _OPT_RV;            # reverse fore- and background colors.
  456. export _OPT_SECTIONS;        # sections for man page search
  457. export _OPT_SYSTEMS;        # man pages of different OS's
  458. export _OPT_TITLE;        # title for gxditview window
  459. export _OPT_TEXT_DEVICE;        # set device for tty mode.
  460. export _OPT_V;            # groff option -V.
  461. export _OPT_VIEWER_DVI;        # viewer program for dvi mode
  462. export _OPT_VIEWER_PDF;        # viewer program for pdf mode
  463. export _OPT_VIEWER_PS;        # viewer program for ps mode
  464. export _OPT_VIEWER_HTML;    # viewer program for html mode
  465. export _OPT_VIEWER_X;        # viewer program for x mode
  466. export _OPT_WHATIS;        # print the one-liner man info
  467. export _OPT_XRM;        # specify X resource.
  468. export _OPT_Z;            # groff option -Z.
  469. # _TMP_* temporary files
  470. export _TMP_DIR;        # groff directory for temporary files
  471. export _TMP_DIR_SUB;        # groffer directory for temporary files
  472. export _TMP_CAT;        # stores concatenation of everything
  473. export _TMP_STDIN;        # stores stdin, if any
  474.  
  475. # these variables are preset in section `Preset' after the rudim. test
  476.  
  477.  
  478. ########################################################################
  479. #             Test of rudimentary shell functionality
  480. ########################################################################
  481.  
  482.  
  483. ########################################################################
  484. # Test of `test'.
  485. #
  486. test "a" = "a" || exit 1;
  487.  
  488.  
  489. ########################################################################
  490. # Test of `echo' and the `$()' construct.
  491. #
  492. echo -n '' >/dev/null || exit "${_ERROR}";
  493. if test "$(echo -n 'te' && echo -n '' && echo -n 'st')" != "test"; then
  494.   exit "${_ERROR}";
  495. fi;
  496.  
  497.  
  498. ########################################################################
  499. # Test of function definitions.
  500. #
  501. _t_e_s_t_f_u_n_c_()
  502. {
  503.   return "${_OK}";
  504. }
  505.  
  506. if _t_e_s_t_f_u_n_c_ 2>/dev/null; then
  507.   :
  508. else
  509.   echo 'shell does not support function definitions.' >&2;
  510.   exit "${_ERROR}";
  511. fi;
  512.  
  513.  
  514. ########################################################################
  515. # Preset and reset of read-write global variables
  516. ########################################################################
  517.  
  518.  
  519. # For variables that can be reset by option `--default', see reset().
  520.  
  521. _FILEARGS='';
  522.  
  523. # _HAS_* from availability tests
  524. _HAS_COMPRESSION='';
  525. _HAS_OPTS_GNU='';
  526. _HAS_OPTS_POSIX='';
  527.  
  528. # _TMP_* temporary files
  529. _TMP_DIR='';
  530. _TMP_DIR_SUB='';
  531. _TMP_CAT='';
  532. _TMP_STDIN='';
  533.  
  534.  
  535. ########################################################################
  536. # reset ()
  537. #
  538. # Reset the variables that can be affected by options to their default.
  539. #
  540. reset()
  541. {
  542.   if test "$#" -ne 0; then
  543.     error "reset() does not have arguments.";
  544.   fi;
  545.  
  546.   _ADDOPTS_GROFF='';
  547.   _ADDOPTS_POST='';
  548.   _ADDOPTS_X='';
  549.   _DISPLAY_ARGS='';
  550.   _DISPLAY_MODE='';
  551.   _DISPLAY_PROG='';
  552.   _REGISTERED_TITLE='';
  553.  
  554.   # _MAN_* finally used configuration of man searching
  555.   _MAN_ALL='no';
  556.   _MAN_ENABLE='yes';        # do search for man-pages
  557.   _MAN_EXT='';
  558.   _MAN_FORCE='no';        # first local file, then search man page
  559.   _MAN_IS_SETUP='no';
  560.   _MAN_LANG='';
  561.   _MAN_LANG_DONE='no';
  562.   _MAN_PATH='';
  563.   _MAN_SEC='';
  564.   _MAN_SEC_DONE='no';
  565.   _MAN_SYS='';
  566.   _MAN_SYS_DONE='no';
  567.  
  568.   # _MANOPT_* as parsed from $MANOPT
  569.   _MANOPT_ALL='no';
  570.   _MANOPT_EXTENSION='';
  571.   _MANOPT_LANG='';
  572.   _MANOPT_PATH='';
  573.   _MANOPT_PAGER='';
  574.   _MANOPT_SEC='';
  575.   _MANOPT_SYS='';
  576.  
  577.   # _OPT_* as parsed from groffer command line
  578.   _OPT_ALL='no';
  579.   _OPT_APROPOS='';
  580.   _OPT_APROPOS_DATA='';
  581.   _OPT_APROPOS_DEVEL='';
  582.   _OPT_APROPOS_PROGS='';
  583.   _OPT_BD='';
  584.   _OPT_BG='';
  585.   _OPT_BW='';
  586.   _OPT_DEBUG='no';
  587.   _OPT_DEFAULT_MODES='';
  588.   _OPT_DEVICE='';
  589.   _OPT_DISPLAY='';
  590.   _OPT_FG='';
  591.   _OPT_FN='';
  592.   _OPT_GEOMETRY='';
  593.   _OPT_ICONIC='no';
  594.   _OPT_LANG='';
  595.   _OPT_LOCATION='no';
  596.   _OPT_MODE='';
  597.   _OPT_MANPATH='';
  598.   _OPT_PAGER='';
  599.   _OPT_RESOLUTION='';
  600.   _OPT_RV='no';
  601.   _OPT_SECTIONS='';
  602.   _OPT_SYSTEMS='';
  603.   _OPT_TITLE='';
  604.   _OPT_TEXT_DEVICE='';
  605.   _OPT_V='no';
  606.   _OPT_VIEWER_DVI='';
  607.   _OPT_VIEWER_PDF='';
  608.   _OPT_VIEWER_PS='';
  609.   _OPT_VIEWER_HTML='';
  610.   _OPT_VIEWER_X='';
  611.   _OPT_WHATIS='no';
  612.   _OPT_XRM='';
  613.   _OPT_Z='no';
  614.  
  615. }
  616.  
  617. reset;
  618.  
  619.  
  620. ########################################################################
  621. #          Functions for error handling and debugging
  622. ########################################################################
  623.  
  624.  
  625. ##############
  626. # landmark (<text>)
  627. #
  628. # Print <text> to standard error as a debugging aid.
  629. #
  630. # Globals: $_DEBUG_LM
  631. #
  632. landmark()
  633. {
  634.   if test "${_DEBUG_LM}" = 'yes'; then
  635.     echo ">>> $*" >&2;
  636.   fi;
  637. }
  638.  
  639. landmark "1: debugging functions";
  640.  
  641.  
  642. ##############
  643. # clean_up ()
  644. #
  645. # Clean up at exit.
  646. #
  647. clean_up()
  648. {
  649.   if test -d "${_TMP_DIR}"; then
  650.     rm -f "${_TMP_DIR}"/*;
  651.     rmdir "${_TMP_DIR}";
  652.   fi;
  653. }
  654.  
  655.  
  656. ##############
  657. # echo2 (<text>*)
  658. #
  659. # Output to stderr.
  660. #
  661. # Arguments : arbitrary text.
  662. #
  663. echo2()
  664. {
  665.   echo "$*" >&2;
  666. }
  667.  
  668.  
  669. ##############
  670. # echo2n (<text>*)
  671. #
  672. # Output to stderr.
  673. #
  674. # Arguments : arbitrary text.
  675. #
  676. echo2n()
  677. {
  678.   echo -n "$*" >&2;
  679. }
  680.  
  681.  
  682. #############
  683. # diag (text>*)
  684. #
  685. # Output a diagnostic message to stderr
  686. #
  687. diag()
  688. {
  689.   echo2 '>>>>>'"$*";
  690. }
  691.  
  692.  
  693. #############
  694. # error (<text>*)
  695. #
  696. # Print an error message to standard error; exit with an error condition
  697. #
  698. error()
  699. {
  700.   local i;
  701.   local _code;
  702.   _code="${_ERROR}";
  703.   case "$#" in
  704.     0) true; ;;
  705.     1) echo2 'groffer error: '"$1"; ;;
  706.     2)
  707.       echo2 'groffer error: '"$1";
  708.       _code="$2";
  709.       ;;
  710.     *) echo2 'groffer error: wrong number of arguments in error().'; ;;
  711.   esac;
  712.   if test "${_DEBUG}" = 'yes'; then
  713.     func_stack_dump;
  714.   fi;
  715.   clean_up;
  716.   kill "${_PROCESS_ID}" >/dev/null 2>&1;
  717.   kill -9 "${_PROCESS_ID}" >/dev/null 2>&1;
  718.   exit "${_code}";
  719. }
  720.  
  721.  
  722. #############
  723. # abort (<text>*)
  724. #
  725. # Terminate program with error condition
  726. #
  727. abort()
  728. {
  729.   error "Program aborted.";
  730.   exit 1;
  731. }
  732.  
  733.  
  734. #############
  735. # func_check (<func_name> <rel_op> <nr_args> "$@")
  736. #
  737. # Check number of arguments and register to _FUNC_STACK.
  738. #
  739. # Arguments: >=3
  740. #   <func_name>: name of the calling function.
  741. #   <rel_op>:    a relational operator: = != < > <= >= 
  742. #   <nr_args>:   number of arguments to be checked against <operator>
  743. #   "$@":        the arguments of the calling function.
  744. #
  745. func_check()
  746. {
  747.   local _comp;
  748.   local _fname;
  749.   local _nargs;
  750.   local _op;
  751.   local _s;
  752.   if test "$#" -lt 3; then
  753.     error 'func_check() needs at least 3 arguments.';
  754.   fi;
  755.   _fname="$1";
  756.   case "$3" in
  757.     1)
  758.       _nargs="$3";
  759.       _s='';
  760.       ;;
  761.     0|[2-9])
  762.       _nargs="$3";
  763.       _s='s';
  764.       ;;
  765.     *)
  766.       error "func_check(): third argument must be a digit.";
  767.       ;;
  768.   esac;
  769.   case "$2" in
  770.     '='|'-eq')
  771.       _op='-eq';
  772.       _comp='exactly';
  773.       ;;
  774.     '>='|'-ge')
  775.       _op='-ge';
  776.       _comp='at least';
  777.       ;;
  778.     '<='|'-le')
  779.       _op='-le';
  780.       _comp='at most';
  781.       ;;
  782.     '<'|'-lt')
  783.       _op='-lt';
  784.       _comp='less than';
  785.       ;;
  786.     '>'|'-gt')
  787.       _op='-gt';
  788.       _comp='more than';
  789.       ;;
  790.     '!='|'-ne')
  791.       _op='-ne';
  792.       _comp='not';
  793.       ;;
  794.     *) 
  795.       error \
  796.         'func_check(): second argument is not a relational operator.';
  797.       ;;
  798.   esac;
  799.   shift 3;
  800.   if test "$#" "${_op}" "${_nargs}"; then
  801.     do_nothing;
  802.   else
  803.     error \
  804.       "${_fname}"'() needs '"${_comp} ${_nargs}"' argument'"${_s}"'.';
  805.   fi;
  806.   if test "${_DEBUG}" = 'yes'; then
  807.     func_push "${_fname} $*";
  808.   fi;
  809. }
  810.  
  811.  
  812. #############
  813. # func_pop ()
  814. #
  815. # Retrieve the top element from the stack.
  816. #
  817. # The stack elements are separated by `!'; the popped element is
  818. # identical to the original element, except that all `!' characters
  819. # were removed.
  820. #
  821. # Arguments: 1
  822. #
  823. func_pop()
  824. {
  825.   if test "${_DEBUG}" = 'yes'; then
  826.     if test "$#" -ne 0; then
  827.       error 'func_pop() does not have arguments.';
  828.     fi;
  829.     case "${_FUNC_STACK}" in
  830.       '')
  831.         error 'func_pop(): stack is empty.';
  832.         ;;
  833.       *!*)
  834.         # split at first bang `!'.
  835.         _FUNC_STACK="$(echo -n ${_FUNC_STACK} \
  836.                        | sed -e 's/^[^!]*!//')";
  837.         ;;
  838.       *)
  839.         _FUNC_STACK='';
  840.         ;;
  841.     esac;
  842.   fi;
  843. }
  844.  
  845.  
  846. #############
  847. # func_push (<element>)
  848. #
  849. # Store another element to stack.
  850. #
  851. # The stack elements are separated by `!'; if <element> contains a `!'
  852. # it is removed first.
  853. #
  854. # Arguments: 1
  855. #
  856. func_push()
  857. {
  858.   local _element;
  859.   if test "${_DEBUG}" = 'yes'; then
  860.     if test "$#" -ne 1; then
  861.       error 'func_push() needs 1 argument.';
  862.     fi;
  863.     case "$1" in
  864.       *'!'*)
  865.         # remove all bangs `!'.
  866.         _element="$(echo -n "$1" | sed -e 's/!//g')";
  867.         ;;
  868.       *)
  869.         _element="$1";
  870.         ;;
  871.     esac;
  872.     if test "${_FUNC_STACK}" = ''; then
  873.       _FUNC_STACK="${_element}";
  874.     else
  875.       _FUNC_STACK="${_element}!${_FUNC_STACK}";
  876.     fi;
  877.   fi;
  878. }
  879.  
  880.  
  881. #############
  882. # func_stack_dump ()
  883. #
  884. # Print the content of the stack.  Ignore the arguments.
  885. #
  886. func_stack_dump()
  887. {
  888.   diag 'call stack:';
  889.   case "${_FUNC_STACK}" in
  890.     *!*)
  891.       _rest="${_FUNC_STACK}";
  892.       while test "${_rest}" != ''; do
  893.         # get part before the first bang `!'.
  894.         diag "$(echo -n "${_rest}" | sed -e 's/!.*$//')";
  895.         # delete part before and including the first bang `!'.
  896.         _rest="$(echo -n "${_rest}" | sed -e 's/^[^!]*!//')";
  897.       done;
  898.       ;;
  899.     *)
  900.       diag "${_FUNC_STACK}";
  901.       ;;
  902.   esac;
  903. }
  904.  
  905.  
  906. ########################################################################
  907. #                        System Test
  908. ########################################################################
  909.  
  910. landmark "2: system test";
  911.  
  912. # Test the availability of the system utilities used in this script.
  913.  
  914.  
  915. ########################################################################
  916. # Test of `true'.
  917. #
  918. if true >/dev/null 2>&1; then
  919.   true;
  920. else
  921.   true()
  922.   {
  923.     return "${_GOOD}";
  924.   }
  925.  
  926.   false()
  927.   {
  928.     return "${_BAD}";
  929.   }
  930. fi;
  931.  
  932.  
  933. ########################################################################
  934. # Test of `unset'.
  935. #
  936. _test='test';
  937. if unset _test >/dev/null 2>&1 && test "${_test}" = ''; then
  938.   true;
  939. else
  940.   unset()
  941.   {
  942.     for v in "$@"; do
  943.       eval "$v"='';
  944.     done;
  945.   }
  946. fi;
  947. unset _test;
  948.  
  949. ########################################################################
  950. # Test of builtin `local'
  951. #
  952.  
  953. _t_e_s_t_f_u_n_c_()
  954. {
  955.   local _test >/dev/null 2>&1 || return "${_BAD}";
  956. }
  957.  
  958. if _t_e_s_t_f_u_n_c_; then
  959.   :
  960. else
  961.   local()
  962.   {
  963.     if test "$1" != ''; then
  964.       error "overriding global variable \`$1' with local value.";
  965.     fi;
  966.   }
  967. fi;
  968.  
  969.  
  970. ########################################################################
  971. # Test of global setting in functions
  972. #
  973. _global='outside';
  974. _clobber='outside';
  975.  
  976. _t_e_s_t_f_u_n_c_()
  977. {
  978.   local _clobber;
  979.   _global='inside';
  980.   _clobber='inside';
  981. }
  982.  
  983. _t_e_s_t_f_u_n_c_;
  984. if test "${_global}" != 'inside' || test "${_clobber}" != 'outside';
  985. then
  986.   error "Cannot assign to global variables from within functions.";
  987. fi;
  988.  
  989. unset _global;
  990. unset _clobber;
  991.  
  992.  
  993. ########################################################################
  994. # Test of function `sed'.
  995. #
  996. if test "$(echo xTesTx \
  997.            | sed -e 's/^.\([Tt]e*x*sTT*\).*$/\1/' \
  998.            | sed -e '\|T|s||t|g')" != 'test';
  999. then
  1000.   error 'Test of "sed" command failed.';
  1001. fi;
  1002.  
  1003.  
  1004. ########################################################################
  1005. # Test of function `cat'.
  1006. #
  1007. if test "$(echo test | cat)" != "test"; then
  1008.   error 'Test of "cat" command failed.';
  1009. fi;
  1010.  
  1011.  
  1012. ########################################################################
  1013. # Test for compression.
  1014. #
  1015. if test "$(echo 'test' | gzip -c -d -f - 2>/dev/null)" = 'test'; then
  1016.   _HAS_COMPRESSION='yes';
  1017.   if echo 'test' | bzip2 -c 2>/dev/null | bzip2 -t 2>/dev/null \
  1018.      && test "$(echo 'test' | bzip2 -c 2>/dev/null \
  1019.                             | bzip2 -d -c 2>/dev/null)" \
  1020.              = 'test'; then
  1021.     _HAS_BZIP='yes';
  1022.   else
  1023.     _HAS_BZIP='no';
  1024.   fi;
  1025. else
  1026.   _HAS_COMPRESSION='no';
  1027.   _HAS_BZIP='no';
  1028. fi;
  1029.  
  1030.  
  1031. ########################################################################
  1032. _t_e_s_t_f_u_n_c_()
  1033. {
  1034.   :
  1035. }
  1036.  
  1037.  
  1038. ########################################################################
  1039. #                   Definition of normal Functions
  1040. ########################################################################
  1041. landmark "3: functions";
  1042.  
  1043. ########################################################################
  1044. # abort (<text>*)
  1045. #
  1046. # Unconditionally terminate the program with error code;
  1047. # useful for debugging.
  1048. #
  1049. # defined above
  1050.  
  1051.  
  1052. ########################################################################
  1053. # apropos_run (<name>)
  1054. #
  1055. # 
  1056. apropos_run() {
  1057.   func_check apropos_run = 1 "$@";
  1058.   if apropos apropos >/dev/null 2>/dev/null; then
  1059.     apropos "$1";
  1060.   elif man --apropos man >/dev/null 2>/dev/null; then
  1061.     man --apropos "$1";
  1062.   elif man -k man >/dev/null 2>/dev/null; then
  1063.     man -k "$1";
  1064.   fi;
  1065. }
  1066.  
  1067.  
  1068. ########################################################################
  1069. # base_name (<path>)
  1070. #
  1071. # Get the file name part of <path>, i.e. delete everything up to last
  1072. # `/' from the beginning of <path>.  Remove final slashes, too, to get a
  1073. # non-empty output.
  1074. #
  1075. # Arguments : 1
  1076. # Output    : the file name part (without slashes)
  1077. #
  1078. base_name()
  1079. {
  1080.   func_check base_name = 1 "$@";
  1081.   local f;
  1082.   f="$1";
  1083.   case "$f" in
  1084.     */)
  1085.       # delete all final slashes
  1086.       f="$(echo -n "$f" | sed -e '\|//*$|s|||')";
  1087.       ;;
  1088.   esac;
  1089.   case "$f" in
  1090.     /|'')
  1091.       eval "${return_bad}";
  1092.       ;;
  1093.     */*)
  1094.       # delete everything before and including the last slash `/'.
  1095.       echo -n "$f" | sed -e '\|^.*//*\([^/]*\)$|s||\1|';
  1096.       ;;
  1097.     *)
  1098.       echo -n "$f";
  1099.       ;;
  1100.   esac;
  1101.   eval "${return_ok}";
  1102. }
  1103.  
  1104.  
  1105. ########################################################################
  1106. # catz (<file>)
  1107. #
  1108. # Decompress if possible or just print <file> to standard output.
  1109. #
  1110. # gzip, bzip2, and .Z decompression is supported.
  1111. #
  1112. # Arguments: 1, a file name.
  1113. # Output: the content of <file>, possibly decompressed.
  1114. #
  1115. if test "${_HAS_COMPRESSION}" = 'yes'; then
  1116.   catz()
  1117.   {
  1118.     func_check catz = 1 "$@";
  1119.     case "$1" in
  1120.       '')
  1121.         error 'catz(): empty file name';
  1122.         ;;
  1123.       '-')
  1124.         error 'catz(): for standard input use save_stdin()';
  1125.         ;;
  1126.     esac;
  1127.     if obj _HAS_BZIP is_yes; then
  1128.       if bzip2 -t "$1" 2>/dev/null; then
  1129.         bzip2 -c -d "$1" 2>/dev/null;
  1130.         eval "${return_ok}";
  1131.       fi;
  1132.     fi;
  1133.     gzip -c -d -f "$1" 2>/dev/null;
  1134.     eval "${return_ok}";
  1135.   }
  1136. else
  1137.   catz()
  1138.   {
  1139.     func_check catz = 1 "$@";
  1140.     cat "$1";
  1141.     eval "${return_ok}";
  1142.   }
  1143. fi;
  1144.  
  1145.  
  1146. ########################################################################
  1147. # clean_up ()
  1148. #
  1149. # Do the final cleaning up before exiting; used by the trap calls.
  1150. #
  1151. # defined above
  1152.  
  1153.  
  1154. ########################################################################
  1155. # diag (<text>*)
  1156. #
  1157. # Print marked message to standard error; useful for debugging.
  1158. #
  1159. # defined above
  1160.  
  1161.  
  1162. ########################################################################
  1163. landmark '4: dirname()*';
  1164. ########################################################################
  1165.  
  1166. #######################################################################
  1167. # dirname_append (<dir> <name>)
  1168. #
  1169. # Append `name' to `dir' with clean handling of `/'.
  1170. #
  1171. # Arguments : 2
  1172. # Output    : the generated new directory name <dir>/<name>
  1173. #
  1174. dirname_append()
  1175. {
  1176.   func_check dirname_append = 2 "$@";
  1177.   local _res;
  1178.   if is_empty "$1"; then
  1179.     error "dir_append(): first argument is empty.";
  1180.   fi;
  1181.   if is_empty "$2"; then
  1182.     echo -n "$1";
  1183.   else
  1184.     dirname_chop "$1"/"$2";
  1185.   fi;
  1186.   eval "${return_ok}";
  1187. }
  1188.  
  1189.  
  1190. ########################################################################
  1191. # dirname_chop (<name>)
  1192. #
  1193. # Remove unnecessary slashes from directory name.
  1194. #
  1195. # Argument: 1, a directory name.
  1196. # Output:   path without double, or trailing slashes.
  1197. #
  1198. dirname_chop()
  1199. {
  1200.   func_check dirname_chop = 1 "$@";
  1201.   local _arg;
  1202.   local _res;
  1203.   local _sep;
  1204.   # replace all multiple slashes by a single slash `/'.
  1205.   _res="$(echo -n "$1" | sed -e '\|///*|s||/|g')";
  1206.   case "${_res}" in
  1207.     ?*/)
  1208.       # remove trailing slash '/';
  1209.       echo -n "${_res}" | sed -e '\|/$|s|||';
  1210.       ;;
  1211.     *) echo -n "${_res}"; ;;
  1212.   esac;
  1213.   eval "${return_ok}";
  1214. }
  1215.  
  1216.  
  1217. ########################################################################
  1218. # do_filearg (<filearg>)
  1219. #
  1220. # Append the file, man-page, or standard input corresponding to the
  1221. # argument to the temporary file.  If this is compressed in the gzip
  1222. # or Z format it is decompressed.  A title element is generated.
  1223. #
  1224. # Argument either:
  1225. #   - name of an existing files.
  1226. #   - `-' to represent standard input (several times allowed).
  1227. #   - `man:name.(section)' the man-page for `name' in `section'.
  1228. #   - `man:name.section' the man-page for `name' in `section'.
  1229. #   - `man:name' the man-page for `name' in the lowest `section'.
  1230. #   - `name.section' the man-page for `name' in `section'.
  1231. #   - `name' the man-page for `name' in the lowest `section'.
  1232. # Globals :
  1233. #   $_TMP_STDIN, $_MAN_ENABLE, $_MAN_IS_SETUP, $_OPT_MAN
  1234. #
  1235. # Output  : none
  1236. # Return  : $_GOOD if found, ${_BAD} otherwise.
  1237. #
  1238. do_filearg()
  1239. {
  1240.   func_check do_filearg = 1 "$@";
  1241.   local _filespec;
  1242.   local i;
  1243.   _filespec="$1";
  1244.   # store sequence into positional parameters
  1245.   case "${_filespec}" in
  1246.     '')
  1247.        eval "${return_good}";
  1248.        ;;
  1249.     '-')
  1250.       register_file '-';
  1251.       eval "${return_good}";
  1252.       ;;
  1253.     */*)            # with directory part; so no man search
  1254.       set -- 'File';
  1255.       ;;
  1256.     *)
  1257.       if obj _MAN_ENABLE is_yes; then
  1258.         if obj _MAN_FORCE is_yes; then
  1259.           set -- 'Manpage' 'File';
  1260.         else
  1261.           set -- 'File' 'Manpage';
  1262.         fi;
  1263.       else
  1264.         set -- 'File';
  1265.       fi;
  1266.       ;;
  1267.   esac;
  1268.   for i in "$@"; do
  1269.     case "$i" in
  1270.       File)
  1271.         if test -f "${_filespec}"; then
  1272.           if test -r "${_filespec}"; then
  1273.             register_file "${_filespec}";
  1274.             eval "${return_good}";
  1275.           else
  1276.         echo2 "could not read \`${_filespec}'";
  1277.             eval "${return_bad}";
  1278.           fi;
  1279.         else
  1280.           continue;
  1281.         fi;
  1282.         ;;
  1283.       Manpage)            # parse filespec as man page
  1284.         if obj _MAN_IS_SETUP is_not_yes; then
  1285.           man_setup;
  1286.         fi;
  1287.         if man_do_filespec "${_filespec}"; then
  1288.           eval "${return_good}";
  1289.         else
  1290.           continue;
  1291.     fi;
  1292.         ;;
  1293.     esac;
  1294.   done;
  1295.   eval "${return_bad}";
  1296. } # do_filearg()
  1297.  
  1298.  
  1299. ########################################################################
  1300. # do_nothing ()
  1301. #
  1302. # Dummy function.
  1303. #
  1304. do_nothing()
  1305. {
  1306.   return "${_OK}";
  1307. }
  1308.  
  1309.  
  1310. ########################################################################
  1311. # echo2 (<text>*)
  1312. #
  1313. # Print to standard error with final line break.
  1314. #
  1315. # defined above
  1316.  
  1317.  
  1318. ########################################################################
  1319. # echo2n (<text>*)
  1320. #
  1321. # Print to standard error without final line break.
  1322. #
  1323. # defined above
  1324.  
  1325.  
  1326. ########################################################################
  1327. # error (<text>*)
  1328. #
  1329. # Print error message and exit with error code.
  1330. #
  1331. # defined above
  1332.  
  1333.  
  1334. ########################################################################
  1335. # func_check (<func_name> <rel_op> <nr_args> "$@")
  1336. #
  1337. # Check number of arguments and register to _FUNC_STACK.
  1338. #
  1339. # Arguments: >=3
  1340. #   <func_name>: name of the calling function.
  1341. #   <rel_op>:    a relational operator: = != < > <= >= 
  1342. #   <nr_args>:   number of arguments to be checked against <operator>
  1343. #   "$@":        the arguments of the calling function.
  1344. #
  1345. # defined above
  1346.  
  1347. #########################################################################
  1348. # func_pop ()
  1349. #
  1350. # Delete the top element from the function call stack.
  1351. #
  1352. # defined above
  1353.  
  1354.  
  1355. ########################################################################
  1356. # func_push (<element>)
  1357. #
  1358. # Store another element to function call stack.
  1359. #
  1360. # defined above
  1361.  
  1362.  
  1363. ########################################################################
  1364. # func_stack_dump ()
  1365. #
  1366. # Print the content of the stack.
  1367. #
  1368. # defined above
  1369.  
  1370.  
  1371. ########################################################################
  1372. # get_first_essential (<arg>*)
  1373. #
  1374. # Retrieve first non-empty argument.
  1375. #
  1376. # Return  : `1' if all arguments are empty, `0' if found.
  1377. # Output  : the retrieved non-empty argument.
  1378. #
  1379. get_first_essential()
  1380. {
  1381.   func_check get_first_essential '>=' 0 "$@";
  1382.   local i;
  1383.   if is_equal "$#" 0; then
  1384.     eval "${return_ok}";
  1385.   fi;
  1386.   for i in "$@"; do
  1387.     if obj i is_not_empty; then
  1388.       echo -n "$i";
  1389.       eval "${return_ok}";
  1390.     fi;
  1391.   done;
  1392.   eval "${return_bad}";
  1393. }
  1394.  
  1395.  
  1396. ########################################################################
  1397. landmark '5: is_*()';
  1398. ########################################################################
  1399.  
  1400. ########################################################################
  1401. # is_dir (<name>)
  1402. #
  1403. # Test whether `name' is a directory.
  1404. #
  1405. # Arguments : 1
  1406. # Return    : `0' if arg1 is a directory, `1' otherwise.
  1407. #
  1408. is_dir()
  1409. {
  1410.   func_check is_dir = 1 "$@";
  1411.   if test -d "$1" && test -r "$1"; then
  1412.     eval "${return_yes}";
  1413.   fi;
  1414.   eval "${return_no}";
  1415. }
  1416.  
  1417.  
  1418. ########################################################################
  1419. # is_empty (<string>)
  1420. #
  1421. # Test whether `string' is empty.
  1422. #
  1423. # Arguments : <=1
  1424. # Return    : `0' if arg1 is empty or does not exist, `1' otherwise.
  1425. #
  1426. is_empty()
  1427. {
  1428.   func_check is_empty = 1 "$@";
  1429.   if test "$1" = ''; then
  1430.     eval "${return_yes}";
  1431.   fi;
  1432.   eval "${return_no}";
  1433. }
  1434.  
  1435.  
  1436. ########################################################################
  1437. # is_equal (<string1> <string2>)
  1438. #
  1439. # Test whether `string1' is equal to <string2>.
  1440. #
  1441. # Arguments : 2
  1442. # Return    : `0' both arguments are equal strings, `1' otherwise.
  1443. #
  1444. is_equal()
  1445. {
  1446.   func_check is_equal = 2 "$@";
  1447.   if test "$1" = "$2"; then
  1448.     eval "${return_yes}";
  1449.   fi;
  1450.   eval "${return_no}";
  1451. }
  1452.  
  1453.  
  1454. ########################################################################
  1455. # is_file (<name>)
  1456. #
  1457. # Test whether `name' is a readable file.
  1458. #
  1459. # Arguments : 1
  1460. # Return    : `0' if arg1 is a readable file, `1' otherwise.
  1461. #
  1462. is_file()
  1463. {
  1464.   func_check is_file = 1 "$@";
  1465.   if test -f "$1" && test -r "$1"; then
  1466.     eval "${return_yes}";
  1467.   fi;
  1468.   eval "${return_no}";
  1469. }
  1470.  
  1471.  
  1472. ########################################################################
  1473. # is_non_empty_file (<file_name>)
  1474. #
  1475. # Test whether `file_name' is a non-empty existing file.
  1476. #
  1477. # Arguments : <=1
  1478. # Return    :
  1479. #   `0' if arg1 is a non-empty existing file
  1480. #   `1' otherwise
  1481. #
  1482. is_non_empty_file()
  1483. {
  1484.   func_check is_empty = 1 "$@";
  1485.   if is_file "$1"; then
  1486.     if is_not_empty "$(cat "$1" | sed -e '/./q')"; then
  1487.       eval "${return_yes}";
  1488.     fi;
  1489.   fi;
  1490.   eval "${return_no}";
  1491. }
  1492.  
  1493.  
  1494. ########################################################################
  1495. # is_not_dir (<name>)
  1496. #
  1497. # Test whether `name' is not a readable directory.
  1498. #
  1499. # Arguments : 1
  1500. # Return    : `0' if arg1 is a directory, `1' otherwise.
  1501. #
  1502. is_not_dir()
  1503. {
  1504.   func_check is_not_dir = 1 "$@";
  1505.   if is_dir "$1"; then
  1506.     eval "${return_no}";
  1507.   fi;
  1508.   eval "${return_yes}";
  1509. }
  1510.  
  1511.  
  1512. ########################################################################
  1513. # is_not_empty (<string>)
  1514. #
  1515. # Test whether `string' is not empty.
  1516. #
  1517. # Arguments : <=1
  1518. # Return    : `0' if arg1 exists and is not empty, `1' otherwise.
  1519. #
  1520. is_not_empty()
  1521. {
  1522.   func_check is_not_empty = 1 "$@";
  1523.   if is_empty "$1"; then
  1524.     eval "${return_no}";
  1525.   fi;
  1526.   eval "${return_yes}";
  1527. }
  1528.  
  1529.  
  1530. ########################################################################
  1531. # is_not_equal (<string1> <string2>)
  1532. #
  1533. # Test whether `string1' differs from `string2'.
  1534. #
  1535. # Arguments : 2
  1536. #
  1537. is_not_equal()
  1538. {
  1539.   func_check is_not_equal = 2 "$@";
  1540.   if is_equal "$1" "$2"; then
  1541.     eval "${return_no}";
  1542.   fi
  1543.   eval "${return_yes}";
  1544. }
  1545.  
  1546.  
  1547. ########################################################################
  1548. # is_not_file (<filename>)
  1549. #
  1550. # Test whether `name' is a not readable file.
  1551. #
  1552. # Arguments : >=1 (empty allowed), more args are ignored
  1553. #
  1554. is_not_file()
  1555. {
  1556.   func_check is_not_file '>=' 1 "$@";
  1557.   if is_file "$1"; then
  1558.     eval "${return_no}";
  1559.   fi;
  1560.   eval "${return_yes}";
  1561. }
  1562.  
  1563.  
  1564. ########################################################################
  1565. # is_not_prog (<name>)
  1566. #
  1567. # Verify that arg is a not program in $PATH.
  1568. #
  1569. # Arguments : >=1 (empty allowed)
  1570. #   more args are ignored, this allows to specify progs with arguments
  1571. #
  1572. is_not_prog()
  1573. {
  1574.   func_check is_not_prog '>=' 1 "$@";
  1575.   if where "$1" >/dev/null; then
  1576.     eval "${return_no}";
  1577.   fi;
  1578.   eval "${return_yes}";
  1579. }
  1580.  
  1581.  
  1582. ########################################################################
  1583. # is_not_writable (<name>)
  1584. #
  1585. # Test whether `name' is a not a writable file or directory.
  1586. #
  1587. # Arguments : >=1 (empty allowed), more args are ignored
  1588. #
  1589. is_not_writable()
  1590. {
  1591.   func_check is_not_writable '>=' 1 "$@";
  1592.   if is_writable "$1"; then
  1593.     eval "${return_no}";
  1594.   fi;
  1595.   eval "${return_yes}";
  1596. }
  1597.  
  1598.  
  1599. ########################################################################
  1600. # is_not_yes (<string>)
  1601. #
  1602. # Test whether `string' is not "yes".
  1603. #
  1604. # Arguments : 1
  1605. #
  1606. is_not_yes()
  1607. {
  1608.   func_check is_not_yes = 1 "$@";
  1609.   if is_yes "$1"; then
  1610.     eval "${return_no}";
  1611.   fi;
  1612.   eval "${return_yes}";
  1613. }
  1614.  
  1615.  
  1616. ########################################################################
  1617. # is_prog (<name>)
  1618. #
  1619. # Determine whether arg is a program in $PATH
  1620. #
  1621. # Arguments : >=0 (empty allowed)
  1622. #   more args are ignored, this allows to specify progs with arguments
  1623. #
  1624. is_prog()
  1625. {
  1626.   func_check is_prog '>=' 0 "$@";
  1627.   case "$#" in
  1628.   0)
  1629.     eval "${return_no}";
  1630.     ;;
  1631.   *)
  1632.     if where "$1" >/dev/null; then
  1633.       eval "${return_yes}";
  1634.     fi;
  1635.     ;;
  1636.   esac
  1637.   eval "${return_no}";
  1638. }
  1639.  
  1640.  
  1641. ########################################################################
  1642. # is_writable (<name>)
  1643. #
  1644. # Test whether `name' is a writable file or directory.
  1645. #
  1646. # Arguments : >=1 (empty allowed), more args are ignored
  1647. #
  1648. is_writable()
  1649. {
  1650.   func_check is_writable '>=' 1 "$@";
  1651.   if test -r "$1"; then
  1652.     if test -w "$1"; then
  1653.       eval "${return_yes}";
  1654.     fi;
  1655.   fi;
  1656.   eval "${return_no}";
  1657. }
  1658.  
  1659.  
  1660. ########################################################################
  1661. # is_yes (<string>)
  1662. #
  1663. # Test whether `string' has value "yes".
  1664. #
  1665. # Arguments : <=1
  1666. # Return    : `0' if arg1 is `yes', `1' otherwise.
  1667. #
  1668. is_yes()
  1669. {
  1670.   func_check is_yes = 1 "$@";
  1671.   if is_equal "$1" 'yes'; then
  1672.     eval "${return_yes}";
  1673.   fi;
  1674.   eval "${return_no}";
  1675. }
  1676.  
  1677.  
  1678. ########################################################################
  1679. # landmark ()
  1680. #
  1681. # Print debugging information on standard error if $_DEBUG_LM is `yes'.
  1682. #
  1683. # Globals: $_DEBUG_LM
  1684. #
  1685. # Defined in section `Debugging functions'.
  1686.  
  1687.  
  1688. ########################################################################
  1689. # leave ()
  1690. #
  1691. # Clean exit without an error.
  1692. #
  1693. leave()
  1694. {
  1695.   clean_up;
  1696.   exit "${_OK}";
  1697. }
  1698.  
  1699.  
  1700. ########################################################################
  1701. landmark '6: list_*()';
  1702. ########################################################################
  1703. #
  1704. # `list' is an object class that represents an array or list.  Its
  1705. # data consists of space-separated single-quoted elements.  So a list
  1706. # has the form "'first' 'second' '...' 'last'".  See list_append() for
  1707. # more details on the list structure.  The array elements of `list'
  1708. # can be get by `set -- $list`.
  1709.  
  1710.  
  1711. ########################################################################
  1712. # list_append (<list> <element>...)
  1713. #
  1714. # Arguments: >=2
  1715. #   <list>: a variable name for a list of single-quoted elements
  1716. #   <element>:  some sequence of characters.
  1717. # Output: none, but $<list> is set to
  1718. #   if <list> is empty:  "'<element>' '...'"
  1719. #   otherwise:           "$list '<element>' ..."
  1720. #
  1721. list_append()
  1722. {
  1723.   func_check list_append '>=' 2 "$@";
  1724.   local _element;
  1725.   local _list;
  1726.   local _name;
  1727.   _name="$1";
  1728.   eval _list='"${'$1'}"';
  1729.   shift;
  1730.   for s in "$@"; do
  1731.     case "$s" in
  1732.     *\'*)
  1733.       # escape each single quote by replacing each
  1734.       # "'" (squote) by "'\''" (squote bslash squote squote);
  1735.       # note that the backslash must be doubled in the following `sed'
  1736.       _element="$(echo -n "$s" | sed -e 's/'"${_SQUOTE}"'/&\\&&/g')";
  1737.       ;;
  1738.     '')  
  1739.       _element="";
  1740.       ;;
  1741.     *)
  1742.       _element="$s";
  1743.       ;;
  1744.     esac;
  1745.     if obj _list is_empty; then
  1746.       _list="'${_element}'";
  1747.     else
  1748.       _list="${_list} '${_element}'";
  1749.     fi;
  1750.   done;
  1751.   eval "${_name}"='"${_list}"';
  1752.   eval "${return_ok}";
  1753. }
  1754.  
  1755.  
  1756. ########################################################################
  1757. # list_from_cmdline (<s_n> <s_a> <l_n> <l_a> [<cmdline_arg>...])
  1758. #
  1759. # Transform command line arguments into a normalized form.
  1760. #
  1761. # Options, option arguments, and file parameters are identified and
  1762. # output each as a single-quoted argument of its own.  Options and
  1763. # file parameters are separated by a '--' argument.
  1764. #
  1765. # Arguments: >=4
  1766. #   <s_n>: space-separated list of short options without an arg.
  1767. #   <s_a>: space-separated list of short options that have an arg.
  1768. #   <l_n>: space-separated list of long options without an arg.
  1769. #   <l_a>: space-separated list of long options that have an arg.
  1770. #   <cmdline_arg>...: the arguments from a command line, such as "$@",
  1771. #                     the content of a variable, or direct arguments.
  1772. #
  1773. # Globals: $POSIXLY_CORRECT (only kept for compatibility).
  1774. #
  1775. # Output: ['-[-]opt' ['optarg']]... '--' ['filename']...
  1776. #
  1777. # Example:
  1778. #     list_normalize 'a b' 'c' '' 'long' -a f1 -bcarg --long=larg f2
  1779. #   will result in printing:
  1780. #     '-a' '-b' '-c' 'arg' '--long' 'larg' '--' 'f1' 'f2'
  1781. #   If $POSIXLY_CORRECT is not empty, the result will be:
  1782. #     '-a' '--' 'f1' '-bcarg' '--long=larg' 'f2'
  1783. #
  1784. #   Rationale:
  1785. #     In POSIX, the first non-option ends the option processing.
  1786. #     In GNU mode, used by default, non-option arguments are sorted
  1787. #     behind the options.
  1788. #
  1789. #   Use this function only in the following way:
  1790. #     eval set -- "$(args_norm '...' '...' '...' '...' "$@")";
  1791. #     while test "$1" != '--'; do
  1792. #       case "$1" in
  1793. #       ...
  1794. #       esac;
  1795. #       shift;
  1796. #     done;
  1797. #     shift;         #skip '--'
  1798. #     # all positional parameters ("$@") left are file name parameters.
  1799. #
  1800. list_from_cmdline()
  1801. {
  1802.   func_check list_from_cmdline '>=' 4 "$@";
  1803.   local _fparams;
  1804.   local _fn;
  1805.   local _result;
  1806.   local _long_a;
  1807.   local _long_n;
  1808.   local _short_a;
  1809.   local _short_n;
  1810.   _short_n="$(list_get "$1")"; # short options, no argument
  1811.   _short_a="$(list_get "$2")"; # short options with argument
  1812.   _long_n="$(list_get "$3")";     # long options, no argument
  1813.   _long_a="$(list_get "$4")";     # long options with argument
  1814.   shift 4;
  1815.   _fn='list_from_cmdline():';     # for error messages
  1816.   if is_equal "$#" 0; then
  1817.     echo -n "'--'";
  1818.     eval "${return_ok}";
  1819.   fi;
  1820.   _fparams='';
  1821.   _result='';
  1822.   while test "$#" -ge 1; do
  1823.     _arg="$1";
  1824.     shift;
  1825.     case "$_arg" in
  1826.       --) break; ;;
  1827.       --?*)
  1828.         # delete leading '--';
  1829.         _opt="$(echo -n "${_arg}" | sed -e 's/^..//')";
  1830.         if list_has _long_n "${_opt}"; then
  1831.           # long option, no argument
  1832.           list_append _result "--${_opt}";
  1833.           continue;
  1834.         fi;
  1835.         # test on `--opt=arg'
  1836.         if string_contains "${_opt}" '='; then
  1837.           # extract option by deleting from the first '=' to the end
  1838.           _lopt="$(echo -n "${_opt}" | sed -e 's/=.*$//')";
  1839.           if list_has _long_a "${_lopt}"; then
  1840.             # get the option argument by deleting up to first `='
  1841.             _optarg="$(echo -n "${_opt}" | sed -e 's/^[^=]*=//')";
  1842.             list_append _result "--${_lopt}" "${_optarg}";
  1843.             continue;
  1844.           fi;
  1845.         fi;
  1846.         if list_has _long_a "${_opt}"; then
  1847.           # long option with argument
  1848.           if test "$#" -le 0; then
  1849.             error "${_fn} no argument for option --${_opt}."
  1850.           fi;
  1851.           list_append _result "--${_opt}" "$1";
  1852.           shift;
  1853.           continue;
  1854.         fi;
  1855.         error "${_fn} --${_opt} is not an option."
  1856.         ;;
  1857.       -?*)            # short option (cluster)
  1858.         # delete leading `-';
  1859.         _rest="$(echo -n "${_arg}" | sed -e 's/^-//')";
  1860.         while obj _rest is_not_empty; do
  1861.           # get next short option from cluster (first char of $_rest)
  1862.           _optchar="$(echo -n "${_rest}" | sed -e 's/^\(.\).*$/\1/')";
  1863.           # remove first character from ${_rest};
  1864.           _rest="$(echo -n "${_rest}" | sed -e 's/^.//')";
  1865.           if list_has _short_n "${_optchar}"; then
  1866.             list_append _result "-${_optchar}";
  1867.             continue;
  1868.           elif list_has _short_a "${_optchar}"; then
  1869.             if obj _rest is_empty; then
  1870.               if test "$#" -ge 1; then
  1871.                 list_append _result "-${_optchar}" "$1";
  1872.                 shift;
  1873.                 continue;
  1874.               else
  1875.                 error \
  1876.                   "${_fn}"' no argument for option -'"${_optchar}."
  1877.               fi;
  1878.             else        # rest is the argument
  1879.               list_append _result "-${_optchar}" "${_rest}";
  1880.               _rest='';
  1881.               continue;
  1882.             fi;
  1883.           else
  1884.             error "${_fn} unknown option -${_optchar}."
  1885.           fi;
  1886.         done;
  1887.         ;;
  1888.       *)
  1889.     # Here, $_arg is not an option, so a file parameter.
  1890.         # When $POSIXLY_CORRECT is set this ends option parsing;
  1891.         # otherwise, the argument is stored as a file parameter and
  1892.         # option processing is continued.
  1893.         list_append _fparams "${_arg}";
  1894.     if obj POSIXLY_CORRECT is_not_empty; then
  1895.           break;
  1896.         fi;
  1897.         ;;
  1898.     esac;
  1899.   done;
  1900.   list_append _result '--';
  1901.   if obj _fparams is_not_empty; then
  1902.     _result="${_result} ${_fparams}";
  1903.   fi;
  1904.   if test "$#" -gt 0; then
  1905.     list_append _result "$@";
  1906.   fi;
  1907.   echo -n "$_result";
  1908.   eval "${return_ok}";
  1909. } # list_from_cmdline()
  1910.  
  1911.  
  1912. ########################################################################
  1913. # list_from_split (<string> <separator>)
  1914. #
  1915. # In <string>, escape all white space characters and replace each
  1916. # <separator> by space.
  1917. #
  1918. # Arguments: 2: a <string> that is to be split into parts divided by
  1919. #               <separator>
  1920. # Output:    the resulting list string
  1921. #
  1922. list_from_split()
  1923. {
  1924.   func_check list_from_split = 2 "$@";
  1925.   local _s;
  1926.  
  1927.   # precede each space or tab by a backslash `\' (doubled for `sed')
  1928.   _s="$(echo -n "$1" | sed -e 's/\(['"${_SPACE}${_TAB}"']\)/\\\1/g')";
  1929.  
  1930.   # replace split character of string by the list separator ` ' (space).
  1931.   case "$2" in
  1932.     /)                # cannot use normal `sed' separator
  1933.       echo -n "${_s}" | sed -e '\|'"$2"'|s|| |g';
  1934.       ;;
  1935.     ?)                # use normal `sed' separator
  1936.       echo -n "${_s}" | sed -e 's/'"$2"'/ /g';
  1937.       ;;
  1938.     ??*)
  1939.       error 'list_from_split(): separator must be a single character.';
  1940.       ;;
  1941.   esac;
  1942.   eval "${return_ok}";
  1943. }
  1944.  
  1945.  
  1946. ########################################################################
  1947. # list_get (<list>)
  1948. #
  1949. # Check whether <list> is a space-separated list of '-quoted elements.
  1950. #
  1951. # If the test fails an error is raised.
  1952. # If the test succeeds the argument is echoed.
  1953. #
  1954. # Testing criteria:
  1955. #   A list has the form "'first' 'second' '...' 'last'".  So it has a
  1956. #   leading and a final quote and the elements are separated by "' '"
  1957. #   constructs.  If these are all removed there should not be any
  1958. #   unescaped single-quotes left.  Watch out for escaped single
  1959. #   quotes; they have the form '\'' (sq bs sq sq).
  1960.  
  1961. # Arguments: 1
  1962. # Output: the argument <list> unchanged, if the check succeeded.
  1963. #
  1964. list_get()
  1965. {
  1966.   func_check list_get = 1 "$@";
  1967.   local _list;
  1968.   eval _list='"${'$1'}"';
  1969.   # remove leading and final space characters
  1970.   _list="$(echo -n "${_list}" | \
  1971.            sed -e '/^['"${_SPACE}${_TAB}"']*/s///' | \
  1972.            sed -e '/['"${_SPACE}${_TAB}"']*$/s///')";
  1973.   case "${_list}" in
  1974.   '')
  1975.     eval "${return_ok}";
  1976.     ;;
  1977.   \'*\')
  1978.     echo -n "${_list}";
  1979.     eval "${return_ok}";
  1980.     ;;
  1981.   *)
  1982.     error "list_get(): bad list: $1"
  1983.     ;;
  1984.   esac;
  1985.   eval "${return_ok}";
  1986. }
  1987.  
  1988.  
  1989. ########################################################################
  1990. # list_has (<var_name> <element>)
  1991. #
  1992. # Arguments: 2
  1993. #   <var_name>: a variable name for a list of single-quoted elements
  1994. #   <element>:  some sequence of characters.
  1995. # Output:
  1996. #   if <list> is empty:  "'<element>' '...'"
  1997. #   otherwise:           "list '<element>' ..."
  1998. #
  1999. list_has()
  2000. {
  2001.   func_check list_has = 2 "$@";
  2002.   eval _list='"${'$1'}"';
  2003.   if obj _list is_empty; then
  2004.     eval "${return_no}";
  2005.   fi;
  2006.   _element="$2";
  2007.   case "$2" in
  2008.     \'*\')  _element="$2"; ;;
  2009.     *)      _element="'$2'"; ;;
  2010.   esac;
  2011.   if string_contains "${_list}" "${_element}"; then
  2012.     eval "${return_yes}";
  2013.   else
  2014.     eval "${return_no}";
  2015.   fi;
  2016.   eval "${return_ok}";
  2017. }
  2018.  
  2019.  
  2020. ########################################################################
  2021. # list_has_not (<list> <element>)
  2022. #
  2023. # Arguments: 2
  2024. #   <list>:    a space-separated list of single-quoted elements.
  2025. #   <element>: some sequence of characters.
  2026. # Output:
  2027. #   if <list> is empty:  "'<element>' '...'"
  2028. #   otherwise:           "<list> '<element>' ..."
  2029. #
  2030. list_has_not()
  2031. {
  2032.   func_check list_has_not = 2 "$@";
  2033.   eval _list='"${'$1'}"';
  2034.   if obj _list is_empty; then
  2035.     eval "${return_yes}";
  2036.   fi;
  2037.   _element="$2";
  2038.   case "$2" in
  2039.     \'*\')  _element="$2"; ;;
  2040.     *)      _element="'$2'"; ;;
  2041.   esac;
  2042.   if string_contains "${_list}" "${_element}"; then
  2043.     eval "${return_no}";
  2044.   else
  2045.     eval "${return_yes}";
  2046.   fi;
  2047.   eval "${return_ok}";
  2048. }
  2049.  
  2050.  
  2051. ########################################################################
  2052. landmark '7: man_*()';
  2053. ########################################################################
  2054.  
  2055. ########################################################################
  2056. # man_do_filespec (<filespec>)
  2057. #
  2058. # Print suitable man page(s) for filespec to $_TMP_CAT.
  2059. #
  2060. # Arguments : 2
  2061. #   <filespec>: argument of the form `man:name.section', `man:name',
  2062. #               `man:name(section)', `name.section', `name'.
  2063. #
  2064. # Globals   : $_OPT_ALL
  2065. #
  2066. # Output    : none.
  2067. # Return    : `0' if man page was found, `1' else.
  2068. #
  2069. # Only called from do_fileargs(), checks on $MANPATH and
  2070. # $_MAN_ENABLE are assumed.
  2071. #
  2072. man_do_filespec()
  2073. {
  2074.   func_check man_do_filespec = 1 "$@";
  2075.   local _got_one;
  2076.   local _name;
  2077.   local _prevsec;
  2078.   local _res;
  2079.   local _section;
  2080.   local _spec;
  2081.   local _string;
  2082.   local s;
  2083.   if obj _MAN_PATH is_empty; then
  2084.     eval "${return_bad}";
  2085.   fi;
  2086.   if is_empty "$1"; then
  2087.     eval "${return_bad}";
  2088.   fi;
  2089.   _spec="$1";
  2090.   _name='';
  2091.   _section='';
  2092.   case "${_spec}" in
  2093.     */*)            # not a man spec when it contains '/'
  2094.       eval "${return_bad}";
  2095.       ;;
  2096.     man:?*\(?*\))        # man:name(section)
  2097.       _name="$(echo -n "${_spec}" \
  2098.                | sed -e 's/^man:\(..*\)(\(..*\))$/\1/')";
  2099.       _section="$(echo -n "${_spec}" \
  2100.                | sed -e 's/^man:\(..*\)(\(..*\))$/\2/')";
  2101.       ;;
  2102.     man:?*.[0-9on])            # man:name.section
  2103.       _name="$(echo -n "${_spec}" \
  2104.                | sed -e 's/^man:\(..*\)\..$/\1/')";
  2105.       _section="$(echo -n "${_spec}" \
  2106.                | sed -e 's/^.*\(.\)$/\1/')";
  2107.       ;;
  2108.     man:?*)            # man:name
  2109.       _name="$(echo -n "${_spec}" | sed -e 's/^man://')";
  2110.       ;;
  2111.     ?*\(?*\))            # name(section)
  2112.       _name="$(echo -n "${_spec}" \
  2113.                | sed -e 's/^\(..*\)(\(..*\))$/\1/')";
  2114.       _section="$(echo -n "${_spec}" \
  2115.                | sed -e 's/^\(..*\)(\(..*\))$/\2/')";
  2116.       ;;
  2117.     ?*.[0-9on])            # name.section
  2118.       _name="$(echo -n "${_spec}" \
  2119.                | sed -e 's/^\(..*\)\..$/\1/')";
  2120.       _section="$(echo -n "${_spec}" \
  2121.                | sed -e 's/^.*\(.\)$/\1/')";
  2122.       ;;
  2123.     ?*)
  2124.       _name="${_filespec}";
  2125.       ;;
  2126.   esac;
  2127.   if obj _name is_empty; then
  2128.     eval "${return_bad}";
  2129.   fi;
  2130.   _got_one='no';
  2131.   if obj _section is_empty; then
  2132.     eval set -- "${_MAN_AUTO_SEC}";
  2133.     for s in "$@"; do
  2134.       if man_search_section "${_name}" "$s"; then # found
  2135.         if obj _MAN_ALL is_yes; then
  2136.           _got_one='yes';
  2137.         else
  2138.           eval "${return_good}";
  2139.         fi;
  2140.       fi;
  2141.     done;
  2142.   else
  2143.     if man_search_section "${_name}" "${_section}"; then
  2144.       eval "${return_good}";
  2145.     else
  2146.       eval "${return_bad}";
  2147.     fi;
  2148.   fi;
  2149.   if obj _MAN_ALL is_yes && is_yes "${_got_one}"; then
  2150.     eval "${return_good}";
  2151.   fi;
  2152.   eval "${return_bad}";
  2153. } # man_do_filespec()
  2154.  
  2155.  
  2156. ########################################################################
  2157. # man_register_file (<file> <name> [<section>])
  2158. #
  2159. # Write a found man page file and register the title element.
  2160. #
  2161. # Arguments: 1, 2, or 3; maybe empty
  2162. # Output: none
  2163. #
  2164. man_register_file()
  2165. {
  2166.   func_check man_register_file '>=' 2 "$@";
  2167.   case "$#" in
  2168.     2|3) do_nothing; ;;
  2169.     *)
  2170.       error "man_register_file() expects 2 or 3 arguments.";
  2171.       ;;
  2172.   esac;
  2173.   if is_empty "$1"; then
  2174.     error 'man_register_file(): file name is empty';
  2175.   fi;
  2176.   to_tmp "$1";
  2177.   case "$#" in
  2178.     2)
  2179.        register_title "man:$2";
  2180.        eval "${return_ok}";
  2181.        ;;
  2182.     3)
  2183.        register_title "$2.$3";
  2184.        eval "${return_ok}";
  2185.        ;;
  2186.   esac;
  2187.   eval "${return_ok}";
  2188. }
  2189.  
  2190.  
  2191. ########################################################################
  2192. # man_search_section (<name> <section>)
  2193. #
  2194. # Retrieve man pages.
  2195. #
  2196. # Arguments : 2
  2197. # Globals   : $_MAN_PATH, $_MAN_EXT
  2198. # Return    : 0 if found, 1 otherwise
  2199. #
  2200. man_search_section()
  2201. {
  2202.   func_check man_search_section = 2 "$@";
  2203.   local _dir;
  2204.   local _ext;
  2205.   local _got_one;
  2206.   local _name;
  2207.   local _prefix
  2208.   local _section;
  2209.   local d;
  2210.   local f;
  2211.   if obj _MAN_PATH is_empty; then
  2212.     eval "${return_bad}";
  2213.   fi;
  2214.   if is_empty "$1"; then
  2215.     eval "${return_bad}";
  2216.   fi;
  2217.   if is_empty "$2"; then
  2218.     eval "${return_bad}";
  2219.   fi;
  2220.   _name="$1";
  2221.   _section="$2";
  2222.   eval set -- "$(path_split "${_MAN_PATH}")";
  2223.   _got_one='no';
  2224.   if obj _MAN_EXT is_empty; then
  2225.     for d in "$@"; do
  2226.       _dir="$(dirname_append "$d" "man${_section}")";
  2227.       if obj _dir is_dir; then
  2228.         _prefix="$(dirname_append "${_dir}" "${_name}.${_section}")";
  2229.         for f in $(echo -n ${_prefix}*); do
  2230.           if obj f is_file; then
  2231.             if is_yes "${_got_one}"; then
  2232.               register_file "$f";
  2233.             elif obj _MAN_ALL is_yes; then
  2234.               man_register_file "$f" "${_name}";
  2235.             else
  2236.               man_register_file "$f" "${_name}" "${_section}";
  2237.               eval "${return_good}";
  2238.             fi;
  2239.             _got_one='yes';
  2240.           fi;
  2241.         done;
  2242.       fi;
  2243.     done;
  2244.   else
  2245.     _ext="${_MAN_EXT}";
  2246.     # check for directory name having trailing extension
  2247.     for d in "$@"; do
  2248.       _dir="$(dirname_append $d man${_section}${_ext})";
  2249.       if obj _dir is_dir; then
  2250.         _prefix="$(dirname_append "${_dir}" "${_name}.${_section}")";
  2251.         for f in ${_prefix}*; do
  2252.           if obj f is_file; then
  2253.             if is_yes "${_got_one}"; then
  2254.               register_file "$f";
  2255.             elif obj _MAN_ALL is_yes; then
  2256.               man_register_file "$f" "${_name}";
  2257.             else
  2258.               man_register_file "$f" "${_name}" "${_section}";
  2259.               eval "${return_good}";
  2260.             fi;
  2261.             _got_one='yes';
  2262.           fi;
  2263.         done;
  2264.       fi;
  2265.     done;
  2266.     # check for files with extension in directories without extension
  2267.     for d in "$@"; do
  2268.       _dir="$(dirname_append "$d" "man${_section}")";
  2269.       if obj _dir is_dir; then
  2270.         _prefix="$(dirname_append "${_dir}" \
  2271.                                   "${_name}.${_section}${_ext}")";
  2272.         for f in ${_prefix}*; do
  2273.           if obj f is_file; then
  2274.             if is_yes "${_got_one}"; then
  2275.               register_file "$f";
  2276.             elif obj _MAN_ALL is_yes; then
  2277.               man_register_file "$f" "${_name}";
  2278.             else
  2279.               man_register_file "$f" "${_name}" "${_section}";
  2280.               eval "${return_good}";
  2281.             fi;
  2282.             _got_one='yes';
  2283.           fi;
  2284.         done;
  2285.       fi;
  2286.     done;
  2287.   fi;
  2288.   if obj _MAN_ALL is_yes && is_yes "${_got_one}"; then
  2289.     eval "${return_good}";
  2290.   fi;
  2291.   eval "${return_bad}";
  2292. } # man_search_section()
  2293.  
  2294.  
  2295. ########################################################################
  2296. # man_setup ()
  2297. #
  2298. # Setup the variables $_MAN_* needed for man page searching.
  2299. #
  2300. # Globals:
  2301. #   in:     $_OPT_*, $_MANOPT_*, $LANG, $LC_MESSAGES, $LC_ALL,
  2302. #           $MANPATH, $MANROFFSEQ, $MANSEC, $PAGER, $SYSTEM, $MANOPT.
  2303. #   out:    $_MAN_PATH, $_MAN_LANG, $_MAN_SYS, $_MAN_LANG, $_MAN_LANG2,
  2304. #           $_MAN_SEC, $_MAN_ALL
  2305. #   in/out: $_MAN_ENABLE
  2306. #
  2307. # The precedence for the variables related to `man' is that of GNU
  2308. # `man', i.e.
  2309. #
  2310. # $LANG; overridden by
  2311. # $LC_MESSAGES; overridden by
  2312. # $LC_ALL; this has the same precedence as
  2313. # $MANPATH, $MANROFFSEQ, $MANSEC, $PAGER, $SYSTEM; overridden by
  2314. # $MANOPT; overridden by
  2315. # the groffer command line options.
  2316. #
  2317. man_setup()
  2318. {
  2319.   func_check main_man_setup = 0 "$@";
  2320.   local _lang;
  2321.  
  2322.   if obj _MAN_IS_SETUP is_yes; then
  2323.     eval "${return_ok}";
  2324.   fi;
  2325.   _MAN_IS_SETUP='yes';
  2326.  
  2327.   if obj _MAN_ENABLE is_not_yes; then
  2328.     eval "${return_ok}";
  2329.   fi;
  2330.  
  2331.   # determine basic path for man pages
  2332.   _MAN_PATH="$(get_first_essential \
  2333.                "${_OPT_MANPATH}" "${_MANOPT_PATH}" "${MANPATH}")";
  2334.   if obj _MAN_PATH is_empty; then
  2335.     manpath_set_from_path;
  2336.   else
  2337.     _MAN_PATH="$(path_clean "${_MAN_PATH}")";
  2338.   fi;
  2339.   if obj _MAN_PATH is_empty; then
  2340.     if is_prog 'manpath'; then
  2341.       _MAN_PATH="$(manpath 2>/dev/null)"; # not always available
  2342.     fi;
  2343.   fi;
  2344.   if obj _MAN_PATH is_empty; then
  2345.     _MAN_ENABLE="no";
  2346.     eval "${return_ok}";
  2347.   fi;
  2348.  
  2349.   _MAN_ALL="$(get_first_essential "${_OPT_ALL}" "${_MANOPT_ALL}")";
  2350.   if obj _MAN_ALL is_empty; then
  2351.     _MAN_ALL='no';
  2352.   fi;
  2353.  
  2354.   _MAN_SYS="$(get_first_essential \
  2355.               "${_OPT_SYSTEMS}" "${_MANOPT_SYS}" "${SYSTEM}")";
  2356.   _lang="$(get_first_essential \
  2357.            "${_OPT_LANG}" "${LC_ALL}" "${LC_MESSAGES}" "${LANG}")";
  2358.   case "${_lang}" in
  2359.     C|POSIX)
  2360.       _MAN_LANG="";
  2361.       _MAN_LANG2="";
  2362.       ;;
  2363.     ?)
  2364.       _MAN_LANG="${_lang}";
  2365.       _MAN_LANG2="";
  2366.       ;;
  2367.     *)
  2368.       _MAN_LANG="${_lang}";
  2369.       # get first two characters of $_lang
  2370.       _MAN_LANG2="$(echo -n "${_lang}" | sed -e 's/^\(..\).*$/\1/')";
  2371.       ;;
  2372.   esac;
  2373.   # from now on, use only $_LANG, forget about $_OPT_LANG, $LC_*.
  2374.  
  2375.   manpath_add_lang_sys;        # this is very slow
  2376.  
  2377.   _MAN_SEC="$(get_first_essential \
  2378.               "${_OPT_SECT}" "${_MANOPT_SEC}" "${MANSEC}")";
  2379.   if obj _MAN_PATH is_empty; then
  2380.     _MAN_ENABLE="no";
  2381.     eval "${return_ok}";
  2382.   fi;
  2383.  
  2384.   _MAN_EXT="$(get_first_essential \
  2385.               "${_OPT_EXTENSION}" "${_MANOPT_EXTENSION}")";
  2386.   eval "${return_ok}";
  2387. } # man_setup()
  2388.  
  2389.  
  2390. ########################################################################
  2391. landmark '8: manpath_*()';
  2392. ########################################################################
  2393.  
  2394. ########################################################################
  2395. # manpath_add_lang_sys ()
  2396. #
  2397. # Add language and operating system specific directories to man path.
  2398. #
  2399. # Arguments : 0
  2400. # Output    : none
  2401. # Globals:
  2402. #   in:     $_MAN_SYS: has the form `os1,os2,...', a comma separated
  2403. #             list of names of operating systems.
  2404. #           $_MAN_LANG and $_MAN_LANG2: each a single name
  2405. #   in/out: $_MAN_PATH: has the form `dir1:dir2:...', a colon
  2406. #             separated list of directories.
  2407. #
  2408. manpath_add_lang_sys()
  2409. {
  2410.   func_check manpath_add_lang_sys = 0 "$@";
  2411.   local p;
  2412.   local _mp;
  2413.   if obj _MAN_PATH is_empty; then
  2414.     eval "${return_ok}";
  2415.   fi;
  2416.   # twice test both sys and lang
  2417.   eval set -- "$(path_split "${_MAN_PATH}")";
  2418.   _mp='';
  2419.   for p in "$@"; do        # loop on man path directories
  2420.     _mp="$(_manpath_add_lang_sys_single "${_mp}" "$p")";
  2421.   done;
  2422.   eval set -- "$(path_split "${_mp}")";
  2423.   for p in "$@"; do        # loop on man path directories
  2424.     _mp="$(_manpath_add_lang_sys_single "${_mp}" "$p")";
  2425.   done;
  2426.   _MAN_PATH="$(path_chop "${_mp}")";
  2427.   eval "${return_ok}";
  2428. }
  2429.  
  2430.  
  2431. _manpath_add_lang_sys_single()
  2432. {
  2433.   # To the directory in $1 append existing sys/lang subdirectories
  2434.   # Function is necessary to split the OS list.
  2435.   #
  2436.   # globals: in: $_MAN_SYS, $_MAN_LANG, $_MAN_LANG2
  2437.   # argument: 2: `man_path' and `dir'
  2438.   # output: colon-separated path of the retrieved subdirectories
  2439.   #
  2440.   func_check _manpath_add_lang_sys_single = 2 "$@";
  2441.   local d;
  2442.   _res="$1";
  2443.   _parent="$2";
  2444.   eval set -- "$(list_from_split "${_MAN_SYS}" ',')";
  2445.   for d in "$@" "${_MAN_LANG}" "${_MAN_LANG2}"; do
  2446.     _dir="$(dirname_append "${_parent}" "$d")";
  2447.     if obj _res path_not_contains "${_dir}" && obj _dir is_dir; then
  2448.       _res="${_res}:${_dir}";
  2449.     fi;
  2450.   done;
  2451.   if path_not_contains "${_res}" "${_parent}"; then
  2452.     _res="${_res}:${_parent}";
  2453.   fi;
  2454.   path_chop "${_res}";
  2455. }
  2456.  
  2457. # end manpath_add_lang_sys ()
  2458.  
  2459.  
  2460. ########################################################################
  2461. # manpath_set_from_path ()
  2462. #
  2463. # Determine basic search path for man pages from $PATH.
  2464. #
  2465. # Return:    `0' if a valid man path was retrieved.
  2466. # Output:    none
  2467. # Globals:
  2468. #   in:  $PATH
  2469. #   out: $_MAN_PATH
  2470. #
  2471. manpath_set_from_path()
  2472. {
  2473.   func_check manpath_set_from_path = 0 "$@";
  2474.   local _base;
  2475.   local _mandir;
  2476.   local _manpath;
  2477.   local d;
  2478.   local e;
  2479.   _manpath='';
  2480.  
  2481.   # get a basic man path from $PATH
  2482.   if obj PATH is_not_empty; then
  2483.     eval set -- "$(path_split "${PATH}")";
  2484.     for d in "$@"; do
  2485.       # delete the final `/bin' part
  2486.       _base="$(echo -n "$d" | sed -e '\|//*bin/*$|s|||')";
  2487.       for e in /share/man /man; do
  2488.         _mandir="${_base}$e";
  2489.         if test -d "${_mandir}" && test -r "${_mandir}"; then
  2490.         _manpath="${_manpath}:${_mandir}";
  2491.         fi;
  2492.       done;
  2493.     done;
  2494.   fi;
  2495.  
  2496.   # append some default directories
  2497.   for d in /usr/local/share/man /usr/local/man \
  2498.             /usr/share/man /usr/man \
  2499.             /usr/X11R6/man /usr/openwin/man \
  2500.             /opt/share/man /opt/man \
  2501.             /opt/gnome/man /opt/kde/man; do
  2502.     if obj _manpath path_not_contains "$d" && obj d is_dir; then
  2503.       _manpath="${_manpath}:$d";
  2504.     fi;
  2505.   done;
  2506.  
  2507.   _MAN_PATH="${_manpath}";
  2508.   eval "${return_ok}";
  2509. } # manpath_set_from_path()
  2510.  
  2511.  
  2512. ########################################################################
  2513. landmark '9: obj_*()';
  2514. ########################################################################
  2515.  
  2516. ########################################################################
  2517. # obj (<object> <call_name> <arg>...)
  2518. #
  2519. # This works like a method (object function) call for an object.
  2520. # Run "<call_name> $<object> <arg> ...".
  2521. #
  2522. # The first argument represents an object whose data is given as first
  2523. # argument to <call_name>().
  2524. #
  2525. # Argument: >=2
  2526. #           <object>: variable name
  2527. #           <call_name>: a program or function name
  2528. #
  2529. obj()
  2530. {
  2531.   func_check obj '>=' 2 "$@";
  2532.   local func;
  2533.   local var;
  2534.   if is_empty "$2"; then
  2535.     error "obj(): function name is empty."
  2536.   else
  2537.     func="$2";
  2538.   fi;
  2539.   eval arg1='"${'$1'}"';
  2540.   shift;
  2541.   shift;
  2542.   eval "${func}"' "${arg1}" "$@"';
  2543. }
  2544.  
  2545.  
  2546. ########################################################################
  2547. # obj_data (<object>)
  2548. #
  2549. # Print the data of <object>, i.e. the content of $<object>.
  2550. # For possible later extensions.
  2551. #
  2552. # Arguments: 1
  2553. #            <object>: a variable name
  2554. # Output:    the data of <object>
  2555. #
  2556. obj_data()
  2557. {
  2558.   func_check obj '=' 1 "$@";
  2559.   if is_empty "$1"; then
  2560.     error "obj_data(): object name is empty."
  2561.   fi;
  2562.   eval echo -n '"${'$1'}"';
  2563. }
  2564.  
  2565.  
  2566. ########################################################################
  2567. # obj_from_output (<object> <call_name> <arg>...)
  2568. #
  2569. # Run '$<object>="$(<call_name> <arg>...)"' to set the result of a
  2570. # function call to a global variable.
  2571. #
  2572. # Arguments: >=2
  2573. #            <object>: a variable name
  2574. #            <call_name>: the name of a function or program
  2575. #            <arg>: optional argument to <call_name>
  2576. # Output:    none
  2577. #
  2578. obj_from_output()
  2579. {
  2580.   func_check obj_from_output '>=' 2 "$@";
  2581.   local result_name;
  2582.   if is_empty "$1"; then
  2583.     error "res(): variable name is empty.";
  2584.   elif is_empty "$2"; then
  2585.     error "res(): function name is empty."
  2586.   else
  2587.     result_name="$1";
  2588.   fi;
  2589.   shift;
  2590.   eval "${result_name}"'="$('"$@"')"';
  2591. }
  2592.  
  2593.  
  2594. ########################################################################
  2595. # obj_set (<object> <data>)
  2596. #
  2597. # Set the data of <object>, i.e. call "$<object>=<data>".
  2598. #
  2599. # Arguments: 2
  2600. #            <object>: a variable name
  2601. #            <data>: a string
  2602. # Output::   none
  2603. #
  2604. obj_set()
  2605. {
  2606.   func_check obj_set '=' 2 "$@";
  2607.   if is_empty "$1"; then
  2608.     error "obj_set(): object name is empty."
  2609.   fi;
  2610.   eval "$1"='"$2"';
  2611. }
  2612.  
  2613.  
  2614. ########################################################################
  2615. # path_chop (<path>)
  2616. #
  2617. # Remove unnecessary colons from path.
  2618. #
  2619. # Argument: 1, a colon separated path.
  2620. # Output:   path without leading, double, or trailing colons.
  2621. #
  2622. path_chop()
  2623. {
  2624.   func_check path_chop = 1 "$@";
  2625.   local _res;
  2626.  
  2627.   # replace multiple colons by a single colon `:'
  2628.   # remove leading and trailing colons
  2629.   echo -n "$1" | sed -e 's/:::*/:/g' |
  2630.                  sed -e 's/^:*//' |
  2631.                  sed -e 's/:*$//';
  2632.   eval "${return_ok}";
  2633. }
  2634.  
  2635.  
  2636. ########################################################################
  2637. # path_clean (<path>)
  2638. #
  2639. # Remove non-existing directories from a colon-separated list.
  2640. #
  2641. # Argument: 1, a colon separated path.
  2642. # Output:   colon-separated list of existing directories.
  2643. #
  2644. path_clean()
  2645. {
  2646.   func_check path_clean = 1 "$@";
  2647.   local _arg;
  2648.   local _dir;
  2649.   local _res;
  2650.   local i;
  2651.   if is_not_equal "$#" 1; then
  2652.     error 'path_clean() needs 1 argument.';
  2653.   fi;
  2654.   _arg="$1";
  2655.   eval set -- "$(path_split "${_arg}")";
  2656.   _res="";
  2657.   for i in "$@"; do
  2658.     if obj i is_not_empty \
  2659.        && obj _res path_not_contains "$i" \
  2660.        && obj i is_dir;
  2661.     then
  2662.       case "$i" in
  2663.         ?*/) _res="${_res}$(dirname_chop "$i")"; ;;
  2664.         *)  _res="${_res}:$i";
  2665.       esac;
  2666.     fi;
  2667.   done;
  2668.   if path_chop "${_res}"; then
  2669.     eval "${return_ok}";
  2670.   else
  2671.     eval "${return_badk}";
  2672.   fi;
  2673. }
  2674.  
  2675.  
  2676. ########################################################################
  2677. # path_contains (<path> <dir>)
  2678. #-
  2679. # Test whether `dir' is contained in `path', a list separated by `:'.
  2680. #
  2681. # Arguments : 2 arguments.
  2682. # Return    : `0' if arg2 is substring of arg1, `1' otherwise.
  2683. #
  2684. path_contains()
  2685. {
  2686.   func_check path_contains = 2 "$@";
  2687.   case ":$1:" in
  2688.     *":$2:"*)
  2689.       eval "${return_yes}";
  2690.       ;;
  2691.     *)
  2692.       eval "${return_no}";
  2693.       ;;
  2694.   esac;
  2695.   eval "${return_ok}";
  2696. }
  2697.  
  2698.  
  2699. ########################################################################
  2700. # path_not_contains (<path> <dir>)
  2701. #-
  2702. # Test whether `dir' is not contained in colon separated `path'.
  2703. #
  2704. # Arguments : 2 arguments.
  2705. #
  2706. path_not_contains()
  2707. {
  2708.   func_check path_not_contains = 2 "$@";
  2709.   if path_contains "$1" "$2"; then
  2710.     eval "${return_no}";
  2711.   else
  2712.     eval "${return_yes}";
  2713.   fi;
  2714.   eval "${return_ok}";
  2715. }
  2716.  
  2717.  
  2718. ########################################################################
  2719. # path_split (<path>)
  2720. #
  2721. # In `path' escape white space and replace each colon by a space.
  2722. #
  2723. # Arguments: 1: a colon-separated path
  2724. # Output:    the resulting list, process with `eval set --'
  2725. #
  2726. path_split()
  2727. {
  2728.   func_check path_split = 1 "$@";
  2729.   list_from_split "$1" ':';
  2730.   eval "${return_ok}";
  2731. }
  2732.  
  2733.  
  2734. ########################################################################
  2735. landmark '10: register_*()';
  2736. ########################################################################
  2737.  
  2738. ########################################################################
  2739. # register_file (<filename>)
  2740. #
  2741. # Write a found file and register the title element.
  2742. #
  2743. # Arguments: 1: a file name
  2744. # Output: none
  2745. #
  2746. register_file()
  2747. {
  2748.   func_check register_file = 1 "$@";
  2749.   if is_empty "$1"; then
  2750.     error 'register_file(): file name is empty';
  2751.   fi;
  2752.   if is_equal "$1" '-'; then
  2753.     to_tmp "${_TMP_STDIN}";
  2754.     register_title '-';
  2755.   else
  2756.     to_tmp "$1";
  2757.     register_title "$(base_name "$1")";
  2758.   fi;
  2759.   eval "${return_ok}";
  2760. }
  2761.  
  2762.  
  2763. ########################################################################
  2764. # register_title (<filespec>)
  2765. #
  2766. # Create title element from <filespec> and append to $_REGISTERED_TITLE
  2767. #
  2768. # Globals: $_REGISTERED_TITLE (rw)
  2769. #
  2770. register_title()
  2771. {
  2772.   func_check register_title = 1 "$@";
  2773.   local _title;
  2774.   if is_empty "$1"; then
  2775.     eval "${return_ok}";
  2776.   fi;
  2777.   _title="$(base_name "$1")";    # remove directory part
  2778.   
  2779.   # remove extension `.gz'
  2780.   _title="$(echo -n "${_title}" | sed -e 's/\.gz$//')";
  2781.   # remove extension `.Z'
  2782.   _title="$(echo -n "${_title}" | sed -e 's/\.Z$//')";
  2783.  
  2784.   if obj _title is_empty; then
  2785.     eval "${return_ok}";
  2786.   fi;
  2787.   _REGISTERED_TITLE="${_REGISTERED_TITLE} ${_title}";
  2788.   eval "${return_ok}";
  2789. }
  2790.  
  2791.  
  2792. ########################################################################
  2793. # reset ()
  2794. #
  2795. # Reset the variables that can be affected by options to their default.
  2796. #
  2797. #
  2798. # Defined in section `Preset' after the rudimentary shell tests.
  2799.  
  2800.  
  2801. ########################################################################
  2802. # save_stdin ()
  2803. #
  2804. # Store standard input to temporary file (with decompression).
  2805. #
  2806. if obj _HAS_COMPRESSION is_yes; then
  2807.   save_stdin()
  2808.   {
  2809.     local _f;
  2810.     func_check save_stdin = 0 "$@";
  2811.      _f="${_TMP_DIR}"/INPUT;
  2812.     cat >"${_f}";
  2813.     catz "${_f}" >"${_TMP_STDIN}";
  2814.     rm -f "${_f}";
  2815.     eval "${return_ok}";
  2816.   }
  2817. else
  2818.   save_stdin()
  2819.   {
  2820.     func_check save_stdin = 0 "$@";
  2821.     cat >"${_TMP_STDIN}";
  2822.     eval "${return_ok}";
  2823.   }
  2824. fi;
  2825.  
  2826.  
  2827. ########################################################################
  2828. landmark '11: stack_*()';
  2829. ########################################################################
  2830.  
  2831. ########################################################################
  2832. # string_contains (<string> <part>)
  2833. #
  2834. # Test whether `part' is contained in `string'.
  2835. #
  2836. # Arguments : 2 text arguments.
  2837. # Return    : `0' if arg2 is substring of arg1, `1' otherwise.
  2838. #
  2839. string_contains()
  2840. {
  2841.   func_check string_contains = 2 "$@";
  2842.   case "$1" in
  2843.     *"$2"*)
  2844.       eval "${return_yes}";
  2845.       ;;
  2846.     *)
  2847.       eval "${return_no}";
  2848.       ;;
  2849.   esac;
  2850.   eval "${return_ok}";
  2851. }
  2852.  
  2853.  
  2854. ########################################################################
  2855. # string_not_contains (<string> <part>)
  2856. #
  2857. # Test whether `part' is not substring of `string'.
  2858. #
  2859. # Arguments : 2 text arguments.
  2860. # Return    : `0' if arg2 is substring of arg1, `1' otherwise.
  2861. #
  2862. string_not_contains()
  2863. {
  2864.   func_check string_not_contains = 2 "$@";
  2865.   if string_contains "$1" "$2"; then
  2866.     eval "${return_no}";
  2867.   else
  2868.     eval "${return_yes}";
  2869.   fi;
  2870.   eval "${return_ok}";
  2871. }
  2872.  
  2873.  
  2874. ########################################################################
  2875. landmark '12: tmp_*()';
  2876. ########################################################################
  2877.  
  2878. ########################################################################
  2879. # tmp_cat ()
  2880. #
  2881. # output the temporary cat file (the concatenation of all input)
  2882. #
  2883. tmp_cat()
  2884. {
  2885.   cat "${_TMP_CAT}";
  2886. }
  2887.  
  2888.  
  2889. ########################################################################
  2890. # tmp_create (<suffix>?)
  2891. #
  2892. # create temporary file
  2893. #
  2894. # It's safe to use the shell process ID together with a suffix to
  2895. # have multiple temporary files.
  2896. #
  2897. # Output : name of created file
  2898. #
  2899. tmp_create()
  2900. {
  2901.   func_check tmp_create '<=' 1 "$@";
  2902.   local _tmp;
  2903.   # the output file does not have `,' as first character
  2904.   _tmp="${_TMP_DIR}/,$1";
  2905.   echo -n >"${_tmp}";
  2906.   echo -n "${_tmp}";        # output file name
  2907.   eval "${return_ok}";
  2908. }
  2909.  
  2910.  
  2911. ########################################################################
  2912. # to_tmp (<filename>)
  2913. #
  2914. # print file (decompressed) to the temporary cat file
  2915. #
  2916. to_tmp()
  2917. {
  2918.   func_check to_tmp = 1 "$@";
  2919.   if is_file "$1"; then
  2920.     if obj _OPT_LOCATION is_yes; then
  2921.       echo2 "$1";
  2922.     fi;
  2923.     if obj _OPT_WHATIS is_yes; then
  2924.       what_is "$1" >>"${_TMP_CAT}";
  2925.     else
  2926.       catz "$1" >>"${_TMP_CAT}";
  2927.     fi;
  2928.   else
  2929.     error "to_tmp(): could not read file \`$1'.";
  2930.   fi;
  2931.   eval "${return_ok}";
  2932. }
  2933.  
  2934.  
  2935. ########################################################################
  2936. # trap_clean ()
  2937. #
  2938. # disable trap on all exit codes ($_ALL_EXIT)
  2939. #
  2940. # Arguments: 0
  2941. # Globals:   $_ALL_EXIT
  2942. #
  2943. trap_clean()
  2944. {
  2945.   func_check trap_clean = 0 "$@";
  2946.   local i;
  2947.   for i in ${_ALL_EXIT}; do
  2948.     trap "" "$i" 2>/dev/null || true;
  2949.   done;
  2950.   eval "${return_ok}";
  2951. }
  2952.  
  2953.  
  2954. ########################################################################
  2955. # trap_set (<functionname>)
  2956. #
  2957. # call function on all exit codes ($_ALL_EXIT)
  2958. #
  2959. # Arguments: 1 (name of a shell function)
  2960. # Globals:   $_ALL_EXIT
  2961. #
  2962. trap_set()
  2963. {
  2964.   func_check trap_set = 1 "$@";
  2965.   local i;
  2966.   for i in ${_ALL_EXIT}; do
  2967.     trap "$1" "$i" 2>/dev/null || true;
  2968.   done;
  2969.   eval "${return_ok}";
  2970. }
  2971.  
  2972.  
  2973. ########################################################################
  2974. # usage ()
  2975. #
  2976. # print usage information to stderr; for groffer option --help.
  2977. #
  2978. usage()
  2979. {
  2980.   func_check usage = 0 "$@";
  2981.   echo;
  2982.   version;
  2983.   echo 'Usage: '"${_PROGRAM_NAME}"' [option]... [filespec]...';
  2984.   cat <<EOF
  2985.  
  2986. Display roff files, standard input, and/or Unix manual pages with a X
  2987. Window viewer or in several text modes.  All input is decompressed
  2988. on-the-fly with all formats that gzip can handle.
  2989.  
  2990. "filespec" is one of
  2991.   "filename"       name of a readable file
  2992.   "-"              for standard input
  2993.   "man:name.n"     man page "name" in section "n"
  2994.   "man:name"       man page "name" in first section found
  2995.   "name.n"         man page "name" in section "n"
  2996.   "name"           man page "name" in first section found
  2997. and some more (see groffer(1) for details).
  2998.  
  2999. -h --help        print this usage message.
  3000. -Q --source      output as roff source.
  3001. -T --device=name pass to groff using output device "name".
  3002. -v --version     print version information.
  3003. -V               display the groff execution pipe instead of formatting.
  3004. -X --X --x       display with "gxditview" using groff -X.
  3005. -Z --ditroff --intermediate-output
  3006.                  generate groff intermediate output without 
  3007.                  post-processing and viewing, like groff -Z.
  3008. All other short options are interpreted as "groff" formatting options.
  3009.  
  3010. The most important groffer long options are
  3011.  
  3012. --apropos=name   start man's "apropos" program for "name".
  3013. --apropos-data=name
  3014.                  "apropos" for "name" in man's data sections 4, 5, 7.
  3015. --apropos-devel=name
  3016.                  "apropos" for "name" in development sections 2, 3, 9.
  3017. --apropos-progs=name
  3018.                  "apropos" for "name" in man's program sections 1, 6, 8.
  3019. --auto           choose mode automatically from the default mode list.
  3020. --default        reset all options to the default value.
  3021. --default-modes=mode1,mode2,...
  3022.                  set sequence of automatically tried modes.
  3023. --dvi            display in a viewer for TeX device independent format.
  3024. --dvi-viewer     choose the viewer program for dvi mode.
  3025. --groff          process like groff, disable viewing features.
  3026. --help           display this helping output.
  3027. --html --www     display in a web browser.
  3028. --html-viewer    choose the web browser for www mode.
  3029. --man            check file parameters first whether they are man pages.
  3030. --mode=auto|dvi|groff|html|pdf|ps|source|text|tty|www|x|X
  3031.                  choose display mode.
  3032. --no-man         disable man-page facility.
  3033. --pager=program  preset the paging program for tty mode.
  3034. --pdf            display in a PDF viewer.
  3035. --pdf-viewer     choose the viewer program for pdf mode.
  3036. --ps             display in a Postscript viewer.
  3037. --ps-viewer      choose the viewer program for ps mode.
  3038. --shell          specify shell under which to run this program.
  3039. --text           output in a text device without a pager.
  3040. --tty            display with a pager on text terminal even when in X.
  3041. --www-viewer     same as --html-viewer
  3042. --x-viewer       choose viewer program for x mode (X mode).
  3043. --X-viewer       same as "--xviewer".
  3044.  
  3045. The usual X Windows toolkit options transformed into GNU long options
  3046. --background=color, --bd=size, --bg=color, --bordercolor=color,
  3047. --borderwidth=size, --bw=size, --display=Xdisplay, --fg=color,
  3048. --fn=font, --font=font, --foreground=color, --geometry=geom, --iconic,
  3049. --resolution=dpi, --rv, --title=text, --xrm=resource
  3050.  
  3051. Long options of GNU "man"
  3052.  --all, --ascii, --ditroff, --extension=suffix, --locale=language,
  3053. --local-file=name, --location, --manpath=dir1:dir2:...,
  3054. --sections=s1:s2:..., --systems=s1,s2,..., --whatis, --where, ...
  3055.  
  3056. EOF
  3057.   eval "${return_ok}";
  3058. }
  3059.  
  3060.  
  3061. ########################################################################
  3062. # version ()
  3063. #
  3064. # print version information to stderr
  3065. #
  3066. version()
  3067. {
  3068.   func_check version = 0 "$@";
  3069.   echo2 "${_PROGRAM_NAME} ${_PROGRAM_VERSION} of ${_LAST_UPDATE}";
  3070.   # also display groff's version, but not the called subprograms
  3071.   groff -v 2>&1 | sed -e '/^ *$/q' | sed -e '1s/^/is part of /' >&2;  
  3072. }
  3073.  
  3074.  
  3075. ########################################################################
  3076. # warning (<string>)
  3077. #
  3078. # Print warning to stderr
  3079. #
  3080. warning()
  3081. {
  3082.   echo2 "warning: $*";
  3083. }
  3084.  
  3085.  
  3086. ########################################################################
  3087. # what_is (<filename>)
  3088. #
  3089. # Interpret <filename> as a man page and display its `whatis'
  3090. # information as a fragment written in the groff language.
  3091. #
  3092. what_is()
  3093. {
  3094.   func_check what_is = 1 "$@";
  3095.   local _res;
  3096.   local _dot;
  3097.   if is_not_file "$1"; then
  3098.     error "what_is(): argument is not a readable file."
  3099.   fi;
  3100.   _dot='^\.['"${_SPACE}${_TAB}"']*';
  3101.   echo '.br';
  3102.   echo "$1: ";
  3103.     echo '.br';
  3104.   echo -n '  ';
  3105.   # grep the line containing `.TH' macro, if any
  3106.   _res="$(catz "$1" | sed -e '/'"${_dot}"'TH /p
  3107. d')";
  3108.   if obj _res is_not_empty; then    # traditional man style
  3109.     # get the text between the first and the second `.SH' macro, by
  3110.     # - delete up to first .SH;
  3111.     # - of this, print everything up to next .SH, and delete the rest;
  3112.     # - of this, delete the final .SH line;
  3113.     catz "$1" | sed -e '1,/'"${_dot}"'SH/d' \
  3114.               | sed -e '1,/'"${_dot}"'SH/p
  3115. d' \
  3116.               | sed -e '/'"${_dot}"'SH/d';
  3117.     eval "${return_ok}";
  3118.   fi;
  3119.   # grep the line containing `.Dd' macro, if any
  3120.   _res="$(catz "$1" | sed -e '/'"${_dot}"'Dd /p
  3121. d')";
  3122.   if obj _res is_not_empty; then    # BSD doc style
  3123.     # get the text between the first and the second `.Nd' macro, by
  3124.     # - delete up to first .Nd;
  3125.     # - of this, print everything up to next .Nd, and delete the rest;
  3126.     # - of this, delete the final .Nd line;
  3127.     catz "$1" | sed -e '1,/'"${_dot}"'Nd/d' \
  3128.               | sed -e '1,/'"${_dot}"'Nd/p
  3129. d' \
  3130.               | sed -e '/'"${_dot}"'Nd/d';
  3131.     eval "${return_ok}";
  3132.   fi;
  3133.   echo 'is not a man page.';
  3134.   eval "${return_bad}";
  3135. }
  3136.  
  3137.  
  3138. ########################################################################
  3139. # where (<program>)
  3140. #
  3141. # Output path of a program if in $PATH.
  3142. #
  3143. # Arguments : >=1 (empty allowed)
  3144. #   more args are ignored, this allows to specify progs with arguments
  3145. # Return    : `0' if arg1 is a program in $PATH, `1' otherwise.
  3146. #
  3147. where()
  3148. {
  3149.   func_check where '>=' 1 "$@";
  3150.   local _file;
  3151.   local _arg;
  3152.   local p;
  3153.   _arg="$1";
  3154.   if obj _arg is_empty; then
  3155.     eval "${return_bad}";
  3156.   fi;
  3157.   case "${_arg}" in
  3158.     /*)
  3159.       if test -f "${_arg}" && test -x "${_arg}"; then
  3160.         eval "${return_ok}";
  3161.       else
  3162.         eval "${return_bad}";
  3163.       fi;
  3164.       ;;
  3165.   esac;
  3166.   eval set -- "$(path_split "${PATH}")";
  3167.   for p in "$@"; do
  3168.     case "$p" in
  3169.       */) _file=${p}${_arg}; ;;
  3170.       *)  _file=${p}/${_arg}; ;;
  3171.     esac;
  3172.     if test -f "${_file}" && test -x "${_file}"; then
  3173.       echo -n "${_file}";
  3174.       eval "${return_ok}";
  3175.     fi;
  3176.   done;
  3177.   eval "${return_bad}";
  3178. }
  3179.  
  3180.  
  3181. ########################################################################
  3182. #                              main
  3183. ########################################################################
  3184.  
  3185. # The main area contains the following parts:
  3186. # - main_init(): initialize temporary files and set exit trap
  3187. # - parse $MANOPT
  3188. # - main_parse_args(): argument parsing
  3189. # - determine display mode
  3190. # - process filespec arguments
  3191. # - setup X resources
  3192. # - do the displaying
  3193.  
  3194. # These parts are implemented as functions, being defined below in the
  3195. # sequence they are called in the main() function.
  3196.  
  3197.  
  3198. #######################################################################
  3199. # main_init ()
  3200. #
  3201. # set exit trap and create temporary files
  3202. #
  3203. # Globals: $_TMP_CAT, $_TMP_STDIN
  3204. #
  3205. landmark '13: main_init()';
  3206. main_init()
  3207. {
  3208.   func_check main_init = 0 "$@";
  3209.   # call clean_up() on any signal
  3210.   trap_set clean_up;
  3211.  
  3212.   # determine temporary directory
  3213.   umask 000;
  3214.   _TMP_DIR='';
  3215.   for d in "${GROFF_TMPDIR}" "${TMPDIR}" "${TMP}" "${TEMP}" \
  3216.            "${TEMPDIR}" "${HOME}"'/tmp' '/tmp' "${HOME}" '.';
  3217.   do
  3218.     if is_not_empty "$d"; then
  3219.       if obj d is_dir && obj d is_writable; then
  3220.         _TMP_DIR="$(mktemp -d "${d}/${_PROGRAM_NAME}.XXXXXX")"
  3221.         if test $? = 0; then
  3222.           break;
  3223.         else
  3224.           _TMP_DIR='';
  3225.       continue;
  3226.       fi;
  3227.       fi;
  3228.       if obj _TMP_DIR is_not_writable; then
  3229.     _TMP_DIR='';
  3230.     continue;
  3231.       fi;
  3232.     fi;
  3233.   done;
  3234.   unset d;
  3235.   if obj _TMP_DIR is_empty; then
  3236.     error "Couldn't create a directory for storing temporary files.";
  3237.   fi;
  3238.  
  3239.   _TMP_CAT="$(tmp_create groffer_cat)";
  3240.   _TMP_STDIN="$(tmp_create groffer_input)";
  3241.  
  3242.   # groffer configuration files
  3243.   for f in ${_CONFFILES}; do
  3244.     if obj f is_file; then
  3245.       echo '_groffer_opt=""' >>${_TMP_CAT};
  3246.       # collect the lines starting with a minus
  3247.       cat "$f" | sed -e \
  3248.         '/^[     ]*\(-.*\)$/s//_groffer_opt="${_groffer_opt} \1"'/ \
  3249.         >>${_TMP_CAT};
  3250.       # prepend the collected information to $GROFFER_OPT
  3251.       echo 'GROFFER_OPT="${_groffer_opt} ${GROFFER_OPT}"' >>${_TMP_CAT};
  3252.     fi;
  3253.   done;
  3254.   . "${_TMP_CAT}";
  3255.   _TMP_CAT="$(tmp_create groffer_cat)";
  3256.  
  3257.   eval "${return_ok}";
  3258. } # main_init()
  3259.  
  3260.  
  3261. ########################################################################
  3262. # main_parse_MANOPT ()
  3263. #
  3264. # Parse $MANOPT to retrieve man options, but only if it is a non-empty
  3265. # string; found man arguments can be overwritten by the command line.
  3266. #
  3267. # Globals:
  3268. #   in: $MANOPT, $_OPTS_MANOPT_*
  3269. #   out: $_MANOPT_*
  3270. #   in/out: $GROFFER_OPT
  3271. #
  3272. landmark '14: main_parse_MANOPT()';
  3273. main_parse_MANOPT()
  3274. {
  3275.   func_check main_parse_MANOPT = 0 "$@";
  3276.   local _opt;
  3277.   local _list;
  3278.   _list='';
  3279.   if obj MANOPT is_not_empty; then
  3280.     MANOPT="$(echo -n "${MANOPT}" | \
  3281.       sed -e 's/^'"${_SPACE}${_SPACE}"'*//')";
  3282.   fi;
  3283.   if obj MANOPT is_empty; then
  3284.     eval "${return_ok}";
  3285.   fi;
  3286.   # add arguments in $MANOPT by mapping them to groffer options
  3287.   eval set -- "$(list_from_cmdline \
  3288.     _OPTS_MANOPT_SHORT_NA _OPTS_MANOPT_SHORT_ARG \
  3289.     _OPTS_MANOPT_LONG_NA _OPTS_MANOPT_LONG_ARG \
  3290.     "${MANOPT}")";
  3291.   until test "$#" -le 0 || is_equal "$1" '--'; do
  3292.     _opt="$1";
  3293.     shift;
  3294.     case "${_opt}" in
  3295.       -7|--ascii)
  3296.         list_append _list '--ascii';
  3297.         ;;
  3298.       -a|--all)
  3299.         list_append _list '--all';
  3300.         ;;
  3301.       -c|--catman)
  3302.         do_nothing;
  3303.         shift;
  3304.         ;;
  3305.       -d|--debug)
  3306.         list_append _list '--debug';
  3307.         ;;
  3308.       -D|--default)
  3309.         # undo all man options so far
  3310.         _list='';
  3311.         ;;
  3312.       -e|--extension)
  3313.         list_append _list '--extension';
  3314.         shift;
  3315.         ;;
  3316.       -f|--whatis)
  3317.         list_append _list '--whatis';
  3318.         shift;
  3319.         ;;
  3320.       -h|--help)
  3321.         do_nothing;
  3322.         shift;
  3323.         ;;
  3324.       -k|--apropos)
  3325.     # groffer's --apropos takes an argument, but man's does not, so
  3326.         do_nothing;
  3327.         shift;
  3328.         ;;
  3329.       -l|--local-file)
  3330.         list_append _list '--local-file';
  3331.         ;;
  3332.       -L|--locale)
  3333.         list_append _list '--locale' "$1";
  3334.         shift;
  3335.         ;;
  3336.       -m|--systems)
  3337.         list_append _list '--systems' "$1";
  3338.         shift;
  3339.         ;;
  3340.       -M|--manpath)
  3341.         list_append _list '--manpath' "$1";
  3342.         shift;
  3343.         ;;
  3344.       -p|--preprocessor)
  3345.         do_nothing;
  3346.         shift;
  3347.         ;;
  3348.       -P|--pager|--tty-viewer)
  3349.         list_append _list '--pager' "$1";
  3350.         shift;
  3351.         ;;
  3352.       -r|--prompt)
  3353.         do_nothing;
  3354.         shift;
  3355.         ;;
  3356.       -S|--sections)
  3357.         list_append _list '--sections' "$1";
  3358.         shift;
  3359.         ;;
  3360.       -t|--troff)
  3361.         do_nothing;
  3362.         shift;
  3363.         ;;
  3364.       -T|--device)
  3365.         list_append _list '-T' "$1";
  3366.         shift;
  3367.         ;;
  3368.       -u|--update)
  3369.         do_nothing;
  3370.         shift;
  3371.         ;;
  3372.       -V|--version)
  3373.         do_nothing;
  3374.         ;;
  3375.       -w|--where|--location)
  3376.         list_append _list '--location';
  3377.         ;;
  3378.       -Z|--ditroff)
  3379.         list_append _list '-Z' "$1";
  3380.         shift;
  3381.         ;;
  3382.       # ignore all other options
  3383.     esac;
  3384.   done;
  3385.   # append the 2 lists in $_list and $GROFFER_OPT to $GROFFER_OPT
  3386.   if obj GROFFER_OPT is_empty; then
  3387.     GROFFER_OPT="${_list}";
  3388.   elif obj _list is_not_empty; then
  3389.     GROFFER_OPT="${_list} ${GROFFER_OPT}";
  3390.   fi;
  3391.   eval "${return_ok}";
  3392. } # main_parse_MANOPT()
  3393.  
  3394.  
  3395. ########################################################################
  3396. # main_parse_args (<command_line_args>*)
  3397. #
  3398. # Parse arguments; process options and filespec parameters
  3399. #
  3400. # Arguments: pass the command line arguments unaltered.
  3401. # Globals:
  3402. #   in:  $_OPTS_*
  3403. #   out: $_OPT_*, $_ADDOPTS, $_FILEARGS
  3404. #
  3405. landmark '15: main_parse_args()';
  3406. main_parse_args()
  3407. {
  3408.   func_check main_parse_args '>=' 0 "$@";
  3409.   local _arg;
  3410.   local _code;
  3411.   local _dpi;
  3412.   local _longopt;
  3413.   local _mode;
  3414.   local _opt;
  3415.   local _optchar;
  3416.   local _optarg;
  3417.   local _opts;
  3418.   local _string;
  3419.  
  3420.   eval set -- "${GROFFER_OPT}" '"$@"';
  3421.  
  3422.   eval set -- "$(list_from_cmdline \
  3423.    _OPTS_CMDLINE_SHORT_NA _OPTS_CMDLINE_SHORT_ARG \
  3424.    _OPTS_CMDLINE_LONG_NA _OPTS_CMDLINE_LONG_ARG \
  3425.    "$@")";
  3426.  
  3427. # By the call of `eval', unnecessary quoting was removed.  So the
  3428. # positional shell parameters ($1, $2, ...) are now guaranteed to
  3429. # represent an option or an argument to the previous option, if any;
  3430. # then a `--' argument for separating options and
  3431. # parameters; followed by the filespec parameters if any.
  3432.  
  3433. # Note, the existence of arguments to options has already been checked.
  3434. # So a check for `$#' or `--' should not be done for arguments.
  3435.  
  3436.   until test "$#" -le 0 || is_equal "$1" '--'; do
  3437.     _opt="$1";            # $_opt is fed into the option handler
  3438.     shift;
  3439.     case "${_opt}" in
  3440.       -h|--help)
  3441.         usage;
  3442.         leave;
  3443.         ;;
  3444.       -Q|--source)        # output source code (`Quellcode').
  3445.         _OPT_MODE='source';
  3446.         ;;
  3447.       -T|--device|--troff-device) # device; arg
  3448.         _OPT_DEVICE="$1";
  3449.         _check_device_with_mode;
  3450.         shift;
  3451.         ;;
  3452.       -v|--version)
  3453.         version;
  3454.         leave;
  3455.         ;;
  3456.       -V)
  3457.         _OPT_V='yes';
  3458.         ;;
  3459.       -Z|--ditroff|--intermediate-output) # groff intermediate output
  3460.         _OPT_Z='yes';
  3461.         ;;
  3462.       -X|--X|--x)
  3463.         _OPT_MODE=x;
  3464.         ;;
  3465.       -?)
  3466.         # delete leading `-'
  3467.         _optchar="$(echo -n "${_opt}" | sed -e 's/^.//')";
  3468.         if list_has _OPTS_GROFF_SHORT_NA "${_optchar}";
  3469.         then
  3470.           list_append _ADDOPTS_GROFF "${_opt}";
  3471.         elif list_has _OPTS_GROFF_SHORT_ARG "${_optchar}";
  3472.         then
  3473.           list_append _ADDOPTS_GROFF "${_opt}" "$1";
  3474.           shift;
  3475.         else
  3476.           error "Unknown option : \`$1'";
  3477.         fi;
  3478.         ;;
  3479.       --all)
  3480.           _OPT_ALL="yes";
  3481.           ;;
  3482.       --ascii)
  3483.         list_append _ADDOPTS_GROFF '-mtty-char';
  3484.         if obj _mode is_empty; then
  3485.           _mode='text';
  3486.         fi;
  3487.         ;;
  3488.       --apropos)        # run `apropos'
  3489.     apropos_run "$1";
  3490.         _code="$?";
  3491.         clean_up;
  3492.         exit "${_code}";
  3493.         ;;
  3494.       --apropos-data)        # run `apropos' for data sections
  3495.     apropos_run "$1" | grep '^[^(]*([457])';
  3496.         _code="$?";
  3497.         clean_up;
  3498.         exit "${_code}";
  3499.         ;;
  3500.       --apropos-devel)        # run `apropos' for development sections
  3501.     apropos_run "$1" | grep '^[^(]*([239])';
  3502.         _code="$?";
  3503.         clean_up;
  3504.         exit "${_code}";
  3505.         ;;
  3506.       --apropos-progs)        # run `apropos' for program sections
  3507.     apropos_run "$1" | grep '^[^(]*([168])';
  3508.         _code="$?";
  3509.         clean_up;
  3510.         exit "${_code}";
  3511.         ;;
  3512.       --auto)            # the default automatic mode
  3513.         _mode='';
  3514.         ;;
  3515.       --bd)            # border color for viewers, arg;
  3516.         _OPT_BD="$1";
  3517.         shift;
  3518.         ;;
  3519.       --bg|--backgroud)        # background color for viewers, arg;
  3520.         _OPT_BG="$1";
  3521.         shift;
  3522.         ;;
  3523.       --bw)            # border width for viewers, arg;
  3524.         _OPT_BW="$1";
  3525.         shift;
  3526.         ;;
  3527.       --default)        # reset variables to default
  3528.         reset;
  3529.         ;;
  3530.       --default-modes)        # sequence of modes in auto mode; arg
  3531.         _OPT_DEFAULT_MODES="$1";
  3532.         shift;
  3533.         ;;
  3534.       --debug)            # buggy, only for development
  3535.         _OPT_DEBUG='yes';
  3536.         ;;
  3537.       --display)        # set X display, arg
  3538.         _OPT_DISPLAY="$1";
  3539.         shift;
  3540.         ;;
  3541.       --dvi)
  3542.         _OPT_MODE='dvi';
  3543.         ;;
  3544.       --dvi-viewer)        # viewer program for dvi mode; arg
  3545.         _OPT_VIEWER_DVI="$1";
  3546.         shift;
  3547.         ;;
  3548.       --extension)        # the extension for man pages, arg
  3549.         _OPT_EXTENSION="$1";
  3550.         shift;
  3551.         ;;
  3552.       --fg|--foreground)    # foreground color for viewers, arg;
  3553.         _OPT_FG="$1";
  3554.         shift;
  3555.         ;;
  3556.       --fn|--font)        # set font for viewers, arg;
  3557.         _OPT_FN="$1";
  3558.         shift;
  3559.         ;;
  3560.       --geometry)        # window geometry for viewers, arg;
  3561.         _OPT_GEOMETRY="$1";
  3562.         shift;
  3563.         ;;
  3564.       --groff)
  3565.         _OPT_MODE='groff';
  3566.         ;;
  3567.       --html|--www)        # display with web browser
  3568.         _OPT_MODE=html;
  3569.         ;;
  3570.       --html-viewer|--www-viewer) # viewer program for html mode; arg
  3571.         _OPT_VIEWER_HTML="$1";
  3572.         shift;
  3573.         ;;
  3574.       --iconic)            # start viewers as icons
  3575.         _OPT_ICONIC='yes';
  3576.         ;;
  3577.       --locale)            # set language for man pages, arg
  3578.         # argument is xx[_territory[.codeset[@modifier]]] (ISO 639,...)
  3579.         _OPT_LANG="$1";
  3580.         shift;
  3581.         ;;
  3582.       --local-file)        # force local files; same as `--no-man'
  3583.         _MAN_FORCE='no';
  3584.         _MAN_ENABLE='no';
  3585.         ;;
  3586.       --location|--where)    # print file locations to stderr
  3587.         _OPT_LOCATION='yes';
  3588.         ;;
  3589.       --man)            # force all file params to be man pages
  3590.         _MAN_ENABLE='yes';
  3591.         _MAN_FORCE='yes';
  3592.         ;;
  3593.       --manpath)        # specify search path for man pages, arg
  3594.         # arg is colon-separated list of directories
  3595.         _OPT_MANPATH="$1";
  3596.         shift;
  3597.         ;;
  3598.       --mode)            # display mode
  3599.         _arg="$1";
  3600.         shift;
  3601.         case "${_arg}" in
  3602.           auto|'')        # search mode automatically among default
  3603.         _mode='';
  3604.             ;;
  3605.           groff)        # pass input to plain groff
  3606.             _mode='groff';
  3607.             ;;
  3608.           html|www)        # display with a web browser
  3609.             _mode='html';
  3610.             ;;
  3611.           dvi)            # display with xdvi viewer
  3612.             _mode='dvi';
  3613.             ;;
  3614.           pdf)            # display with PDF viewer
  3615.             _mode='pdf';
  3616.             ;;
  3617.           ps)            # display with Postscript viewer
  3618.             _mode='ps';
  3619.             ;;
  3620.           text)            # output on terminal
  3621.             _mode='text';
  3622.             ;;
  3623.           tty)            # output on terminal
  3624.             _mode='tty';
  3625.             ;;
  3626.           X|x)            # output on X roff viewer
  3627.             _mode='x';
  3628.             ;;
  3629.           Q|source)        # display source code
  3630.             _mode="source";
  3631.             ;;
  3632.       *)
  3633.             error "unknown mode ${_arg}";
  3634.             ;;
  3635.         esac;
  3636.         _OPT_MODE="${_mode}";
  3637.         ;;
  3638.       --no-location)        # disable former call to `--location'
  3639.         _OPT_LOCATION='yes';
  3640.         ;;
  3641.       --no-man)            # disable search for man pages
  3642.         # the same as --local-file
  3643.         _MAN_FORCE="no";
  3644.         _MAN_ENABLE="no";
  3645.         ;;
  3646.       --pager)            # set paging program for tty mode, arg
  3647.         _OPT_PAGER="$1";
  3648.         shift;
  3649.         ;;
  3650.       --pdf)
  3651.         _OPT_MODE='pdf';
  3652.         ;;
  3653.       --pdf-viewer)        # viewer program for ps mode; arg
  3654.         _OPT_VIEWER_PDF="$1";
  3655.         shift;
  3656.         ;;
  3657.       --ps)
  3658.         _OPT_MODE='ps';
  3659.         ;;
  3660.       --ps-viewer)        # viewer program for ps mode; arg
  3661.         _OPT_VIEWER_PS="$1";
  3662.         shift;
  3663.         ;;
  3664.       --resolution)        # set resolution for X devices, arg
  3665.         _arg="$1";
  3666.         shift;
  3667.         case "${_arg}" in
  3668.           75|75dpi)
  3669.             _dpi=75;
  3670.             ;;
  3671.           100|100dpi)
  3672.             _dpi=100;
  3673.             ;;
  3674.           *)
  3675.             error "only resoutions of 75 or 100 dpi are supported";
  3676.             ;;
  3677.         esac;
  3678.         _OPT_RESOLUTION="${_dpi}";
  3679.         ;;
  3680.       --rv)
  3681.         _OPT_RV='yes';
  3682.         ;;
  3683.       --sections)        # specify sections for man pages, arg
  3684.         # arg is colon-separated list of section names
  3685.         _OPT_SECTIONS="$1";
  3686.         shift;
  3687.         ;;
  3688.       --shell)
  3689.         shift;
  3690.         ;;
  3691.       --systems)        # man pages for different OS's, arg
  3692.         # argument is a comma-separated list
  3693.         _OPT_SYSTEMS="$1";
  3694.         shift;
  3695.         ;;
  3696.       --text)            # text mode without pager
  3697.         _OPT_MODE=text;
  3698.         ;;
  3699.       --title)            # title for X viewers; arg
  3700.         _OPT_TITLE="$1";
  3701.         shift;
  3702.         ;;
  3703.       --tty)            # tty mode, text with pager
  3704.         _OPT_MODE=tty;
  3705.         ;;
  3706.       --text-device|--tty-device) # device for tty mode; arg
  3707.         _OPT_TEXT_DEVICE="$1";
  3708.         shift;
  3709.         ;;
  3710.       --whatis)
  3711.         _OPT_WHATIS='yes';
  3712.         ;;
  3713.       --xrm)            # pass X resource string, arg;
  3714.         list_append _OPT_XRM "$1";
  3715.         shift;
  3716.         ;;
  3717.       --x-viewer|--X-viewer)    # viewer program for x mode; arg
  3718.         _OPT_VIEWER_X="$1";
  3719.         shift;
  3720.         ;;
  3721.       *)
  3722.         error 'error on argument parsing : '"\`$*'";
  3723.         ;;
  3724.     esac;
  3725.   done;
  3726.   shift;            # remove `--' argument
  3727.  
  3728.   if obj _DEBUG is_not_yes; then
  3729.     if obj _OPT_DEBUG is_yes; then
  3730.       _DEBUG='yes';
  3731.     fi;
  3732.   fi;
  3733.  
  3734.   # Remaining arguments are file names (filespecs).
  3735.   # Save them to list $_FILEARGS
  3736.   if is_equal "$#" 0; then    # use "-" for standard input
  3737.     set -- '-';
  3738.   fi;
  3739.   _FILEARGS='';
  3740.   list_append _FILEARGS "$@";
  3741.   if list_has _FILEARGS '-'; then
  3742.     save_stdin;
  3743.   fi;
  3744.   # $_FILEARGS must be retrieved with `eval set -- "$_FILEARGS"'
  3745.   eval "${return_ok}";
  3746. } # main_parse_args()
  3747.  
  3748. # Called from main_parse_args() because double `case' is not possible.
  3749. # Globals: $_OPT_DEVICE, $_OPT_MODE
  3750. _check_device_with_mode()
  3751. {
  3752.   func_check _check_device_with_mode = 0 "$@";
  3753.   case "${_OPT_DEVICE}" in
  3754.     dvi)
  3755.       _OPT_MODE=dvi;
  3756.       eval "${return_ok}";
  3757.       ;;
  3758.     html)
  3759.       _OPT_MODE=html;
  3760.       eval "${return_ok}";
  3761.       ;;
  3762.     lbp|lj4)
  3763.       _OPT_MODE=groff;
  3764.       eval "${return_ok}";
  3765.       ;;
  3766.     ps)
  3767.       _OPT_MODE=ps;
  3768.       eval "${return_ok}";
  3769.       ;;
  3770.     ascii|cp1047|latin1|utf8)
  3771.       if obj _OPT_MODE is_not_equal text; then
  3772.         _OPT_MODE=tty;        # default text mode
  3773.       fi;
  3774.       eval "${return_ok}";
  3775.       ;;
  3776.     X*)
  3777.       _OPT_MODE=x;
  3778.       eval "${return_ok}";
  3779.       ;;
  3780.     *)                # unknown device, go to groff mode
  3781.       _OPT_MODE=groff;
  3782.       eval "${return_ok}";
  3783.       ;;
  3784.   esac;
  3785.   eval "${return_error}";
  3786. }
  3787.  
  3788.  
  3789. ########################################################################
  3790. # main_set_mode ()
  3791. #
  3792. # Determine the display mode.
  3793. #
  3794. # Globals:
  3795. #   in:  $DISPLAY, $_OPT_MODE, $_OPT_DEVICE
  3796. #   out: $_DISPLAY_MODE
  3797. #
  3798.  
  3799. # _get_first_prog (<proglist>)
  3800. #
  3801. # Retrieve first argument that represents an existing program in $PATH.
  3802. # Local function for main_set_mode().
  3803. #
  3804. # Arguments: 1; a comma-separated list of commands (with options),
  3805. #               like $_VIEWER_*.
  3806. #
  3807. # Return  : `1' if none found, `0' if found.
  3808. # Output  : the argument that succeded.
  3809. #
  3810. landmark '16: main_set_mode()';
  3811. main_set_mode()
  3812. {
  3813.   func_check main_set_mode = 0 "$@";
  3814.   local m;
  3815.   local _modes;
  3816.   local _viewer;
  3817.   local _viewers;
  3818.  
  3819.   # handle apropos
  3820.   if obj _OPT_APROPOS is_not_empty; then
  3821.     apropos "${_OPT_APROPOS}";
  3822.     _code="$?";
  3823.     clean_up;
  3824.     exit "${_code}";
  3825.   fi;
  3826.   if obj _OPT_APROPOS_DATA is_not_empty; then
  3827.     apropos "$@" | grep '^[^(]*([457])';
  3828.     _code="$?";
  3829.     clean_up;
  3830.     exit "${_code}";
  3831.   fi;
  3832.   if obj _OPT_APROPOS_DEVEL is_not_empty; then
  3833.     apropos "$@" | grep '^[^(]*([239])';
  3834.     _code="$?";
  3835.     clean_up;
  3836.     exit "${_code}";
  3837.   fi;
  3838.   if obj _OPT_APROPOS_PROGS is_not_empty; then
  3839.     apropos "$@" | grep '^[^(]*([168])';
  3840.     _code="$?";
  3841.     clean_up;
  3842.     exit "${_code}";
  3843.   fi;
  3844.  
  3845.   # set display
  3846.   if obj _OPT_DISPLAY is_not_empty; then
  3847.     DISPLAY="${_OPT_DISPLAY}";
  3848.   fi;
  3849.  
  3850.   if obj _OPT_V is_yes; then
  3851.     _DISPLAY_MODE='groff';
  3852.     list_append _ADDOPTS_GROFF '-V';
  3853.   fi;
  3854.   if obj _OPT_Z is_yes; then
  3855.     _DISPLAY_MODE='groff';
  3856.     list_append _ADDOPTS_GROFF '-Z';
  3857.   fi;
  3858.   if obj _OPT_MODE is_equal 'groff'; then
  3859.     _DISPLAY_MODE='groff';
  3860.   fi;
  3861.   if obj _DISPLAY_MODE is_equal 'groff'; then
  3862.     eval "${return_ok}";
  3863.   fi;
  3864.  
  3865.   if obj _OPT_MODE is_equal 'source'; then
  3866.     _DISPLAY_MODE='source';
  3867.     eval "${return_ok}";
  3868.   fi;
  3869.  
  3870.   case "${_OPT_MODE}" in
  3871.     '')                # automatic mode
  3872.       case "${_OPT_DEVICE}" in
  3873.         X*)
  3874.           if obj DISPLAY is_empty; then
  3875.             error "no X display found for device ${_OPT_DEVICE}";
  3876.           fi;
  3877.           _DISPLAY_MODE='x';
  3878.           eval "${return_ok}";
  3879.           ;;
  3880.         ascii|cp1047|latin1|utf8)
  3881.           if obj _DISPLAY_MODE is_not_equal 'text'; then
  3882.             _DISPLAY_MODE='tty';
  3883.           fi;
  3884.           eval "${return_ok}";
  3885.           ;;
  3886.       esac;
  3887.       if obj DISPLAY is_empty; then
  3888.         _DISPLAY_MODE='tty';
  3889.         eval "${return_ok}";
  3890.       fi;
  3891.  
  3892.       if obj _OPT_DEFAULT_MODES is_empty; then
  3893.         _modes="${_DEFAULT_MODES}";
  3894.       else
  3895.         _modes="${_OPT_DEFAULT_MODES}";
  3896.       fi;
  3897.       ;;
  3898.     text)
  3899.       _DISPLAY_MODE='text';
  3900.       eval "${return_ok}";
  3901.       ;;
  3902.     tty)
  3903.       _DISPLAY_MODE='tty';
  3904.       eval "${return_ok}";
  3905.       ;;
  3906.     *)                # display mode was given
  3907.       if obj DISPLAY is_empty; then
  3908.         error "you must be in X Window for ${_OPT_MODE} mode.";
  3909.       fi;
  3910.       _modes="${_OPT_MODE}";
  3911.       ;;
  3912.   esac;
  3913.  
  3914.   # only viewer modes are left
  3915.   eval set -- "$(list_from_split "${_modes}" ',')";
  3916.   while test "$#" -gt 0; do
  3917.     m="$1";
  3918.     shift;
  3919.     case "$m" in
  3920.       text)
  3921.         _DISPLAY_MODE='text';
  3922.         eval "${return_ok}";
  3923.         ;;
  3924.       tty)
  3925.         _DISPLAY_MODE='tty';
  3926.         eval "${return_ok}";
  3927.         ;;
  3928.       x)
  3929.         if obj _OPT_VIEWER_X is_not_empty; then
  3930.           _viewers="${_OPT_VIEWER_X}";
  3931.         else
  3932.           _viewers="${_VIEWER_X}";
  3933.         fi;
  3934.         _viewer="$(_get_first_prog "${_viewers}")";
  3935.         if is_not_equal "$?" 0; then
  3936.           continue;
  3937.         fi;
  3938.         _DISPLAY_PROG="${_viewer}";
  3939.         _DISPLAY_MODE='x';
  3940.         eval "${return_ok}";
  3941.         ;;
  3942.       dvi)
  3943.         if obj _OPT_VIEWER_DVI is_not_empty; then
  3944.           _viewers="${_OPT_VIEWER_DVI}";
  3945.         else
  3946.           _viewers="${_VIEWER_DVI}";
  3947.         fi;
  3948.         _viewer="$(_get_first_prog "${_viewers}")";
  3949.         if is_not_equal "$?" 0; then
  3950.           continue;
  3951.         fi;
  3952.         _DISPLAY_PROG="${_viewer}";
  3953.         _DISPLAY_MODE="dvi";
  3954.         eval "${return_ok}";
  3955.         ;;
  3956.       pdf)
  3957.         if obj _OPT_VIEWER_PDF is_not_empty; then
  3958.           _viewers="${_OPT_VIEWER_PDF}";
  3959.         else
  3960.           _viewers="${_VIEWER_PDF}";
  3961.         fi;
  3962.         _viewer="$(_get_first_prog "${_viewers}")";
  3963.         if is_not_equal "$?" 0; then
  3964.           continue;
  3965.         fi;
  3966.         _DISPLAY_PROG="${_viewer}";
  3967.         _DISPLAY_MODE="pdf";
  3968.         eval "${return_ok}";
  3969.         ;;
  3970.       ps)
  3971.         if obj _OPT_VIEWER_PS is_not_empty; then
  3972.           _viewers="${_OPT_VIEWER_PS}";
  3973.         else
  3974.           _viewers="${_VIEWER_PS}";
  3975.         fi;
  3976.         _viewer="$(_get_first_prog "${_viewers}")";
  3977.         if is_not_equal "$?" 0; then
  3978.           continue;
  3979.         fi;
  3980.         _DISPLAY_PROG="${_viewer}";
  3981.         _DISPLAY_MODE="ps";
  3982.         eval "${return_ok}";
  3983.         ;;
  3984.       html)
  3985.         if obj _OPT_VIEWER_HTML is_not_empty; then
  3986.           _viewers="${_OPT_VIEWER_HTML}";
  3987.         else
  3988.           _viewers="${_VIEWER_HTML}";
  3989.         fi;
  3990.         _viewer="$(_get_first_prog "${_viewers}")";
  3991.         if is_not_equal "$?" 0; then
  3992.           continue;
  3993.         fi;
  3994.         _DISPLAY_PROG="${_viewer}";
  3995.         _DISPLAY_MODE=html;
  3996.         eval "${return_ok}";
  3997.         ;;
  3998.     esac;
  3999.   done;
  4000.   error "no suitable display mode found.";
  4001. }
  4002.  
  4003. _get_first_prog()
  4004. {
  4005.   local i;
  4006.   if is_equal "$#" 0; then
  4007.     error "_get_first_prog() needs 1 argument.";
  4008.   fi;
  4009.   if is_empty "$1"; then
  4010.     return "${_BAD}";
  4011.   fi;
  4012.   eval set -- "$(list_from_split "$1" ',')";
  4013.   for i in "$@"; do
  4014.     if obj i is_empty; then
  4015.       continue;
  4016.     fi;
  4017.     if is_prog "$(get_first_essential $i)"; then
  4018.       echo -n "$i";
  4019.       return "${_GOOD}";
  4020.     fi;
  4021.   done;
  4022.   return "${_BAD}";
  4023. } # main_set_mode()
  4024.  
  4025.  
  4026. #######################################################################
  4027. # main_do_fileargs ()
  4028. #
  4029. # Process filespec arguments in $_FILEARGS.
  4030. #
  4031. # Globals:
  4032. #   in: $_FILEARGS (process with `eval set -- "$_FILEARGS"')
  4033. #
  4034. landmark '17: main_do_fileargs()';
  4035. main_do_fileargs()
  4036. {
  4037.   func_check main_do_fileargs = 0 "$@";
  4038.   local _exitcode;
  4039.   local _filespec;
  4040.   local _name;
  4041.   _exitcode="${_BAD}";
  4042.   eval set -- "${_FILEARGS}";
  4043.   unset _FILEARGS;
  4044.   # temporary storage of all input to $_TMP_CAT
  4045.   while test "$#" -ge 2; do
  4046.     # test for `s name' arguments, with `s' a 1-char standard section
  4047.     _filespec="$1";
  4048.     shift;
  4049.     case "${_filespec}" in
  4050.       '')
  4051.         continue;
  4052.         ;;
  4053.       '-')
  4054.         if register_file '-'; then
  4055.           _exitcode="${_GOOD}";
  4056.         fi;
  4057.         continue;
  4058.         ;;
  4059.       ?)
  4060.         if list_has_not _MAN_AUTO_SEC "${_filespec}"; then
  4061.           if do_filearg "${_filespec}"; then
  4062.             _exitcode="${_GOOD}";
  4063.           fi;
  4064.           continue;
  4065.         fi;
  4066.         _name="$1";
  4067.         case "${_name}" in
  4068.           */*|man:*|*\(*\)|*."${_filespec}")
  4069.             if do_filearg "${_filespec}"; then
  4070.               _exitcode="${_GOOD}";
  4071.             fi;
  4072.             continue;
  4073.             ;;
  4074.         esac;
  4075.         if do_filearg "man:${_name}(${_filespec})"; then
  4076.           _exitcode="${_GOOD}";
  4077.           shift;
  4078.           continue;
  4079.         else
  4080.           if do_filearg "${_filespec}"; then
  4081.             _exitcode="${_GOOD}";
  4082.           fi;
  4083.           continue;
  4084.         fi;
  4085.         ;;
  4086.       *)
  4087.         if do_filearg "${_filespec}"; then
  4088.           _exitcode="${_GOOD}";
  4089.         fi;
  4090.         continue;
  4091.         ;;
  4092.     esac;
  4093.   done;                # end of `s name' test
  4094.   while test "$#" -gt 0; do
  4095.     _filespec="$1";
  4096.     shift;
  4097.     if do_filearg "${_filespec}"; then
  4098.       _exitcode="${_GOOD}";
  4099.     fi;
  4100.   done;
  4101.   rm -f "${_TMP_STDIN}";
  4102.   if is_equal "${_exitcode}" "${_BAD}"; then
  4103.     eval "${return_bad}";
  4104.   fi;
  4105.   eval "${return_ok}";
  4106. } # main_do_fileargs()
  4107.  
  4108.  
  4109. ########################################################################
  4110. # main_set_resources ()
  4111. #
  4112. # Determine options for setting X resources with $_DISPLAY_PROG.
  4113. # 
  4114. # Globals: $_DISPLAY_PROG, $_OUTPUT_FILE_NAME
  4115. #
  4116. landmark '18: main_set_resources()';
  4117. main_set_resources()
  4118. {
  4119.   func_check main_set_resources = 0 "$@";
  4120.   local _prog;            # viewer program
  4121.   local _rl;            # resource list
  4122.   local n;
  4123.   _title="$(get_first_essential \
  4124.                 "${_OPT_TITLE}" "${_REGISTERED_TITLE}")";
  4125.   _OUTPUT_FILE_NAME='';
  4126.   set -- ${_title};
  4127.   until is_equal "$#" 0; do 
  4128.     n="$1";
  4129.     case "$n" in
  4130.     '')
  4131.       continue;
  4132.       ;;
  4133.     ,*)
  4134.       n="$(echo -n "$1" | sed -e '/^,,*/s///')";
  4135.       ;;
  4136.     esac
  4137.     if obj n is_empty; then
  4138.       continue;
  4139.     fi;
  4140.     if obj _OUTPUT_FILE_NAME is_not_empty; then
  4141.       _OUTPUT_FILE_NAME="${_OUTPUT_FILE_NAME},";
  4142.     fi;
  4143.     _OUTPUT_FILE_NAME="${_OUTPUT_FILE_NAME}$n";
  4144.     shift;
  4145.   done;
  4146.   case "${_OUTPUT_FILE_NAME}" in
  4147.   '')
  4148.     _OUTPUT_FILE_NAME='-';
  4149.     ;;
  4150.   ,*)
  4151.     error "$_OUTPUT_FILE_NAME starts with a comma.";
  4152.     ;;
  4153.   esac;
  4154.   _OUTPUT_FILE_NAME="${_TMP_DIR}/${_OUTPUT_FILE_NAME}";
  4155.  
  4156.   if obj _DISPLAY_PROG is_empty; then # for example, for groff mode
  4157.     _DISPLAY_ARGS='';
  4158.     eval "${return_ok}";
  4159.   fi;
  4160.  
  4161.   set -- ${_DISPLAY_PROG};
  4162.   _prog="$(base_name "$1")";
  4163.   _rl='';
  4164.   if obj _OPT_BD is_not_empty; then
  4165.     case "${_prog}" in
  4166.       ghostview|gv|gxditview|xditview|xdvi)
  4167.         list_append _rl '-bd' "${_OPT_BD}";
  4168.         ;;
  4169.     esac;
  4170.   fi;
  4171.   if obj _OPT_BG is_not_empty; then
  4172.     case "${_prog}" in
  4173.       ghostview|gv|gxditview|xditview|xdvi)
  4174.         list_append _rl '-bg' "${_OPT_BG}";
  4175.         ;;
  4176.       xpdf)
  4177.         list_append _rl '-papercolor' "${_OPT_BG}";
  4178.         ;;
  4179.     esac;
  4180.   fi;
  4181.   if obj _OPT_BW is_not_empty; then
  4182.     case "${_prog}" in
  4183.       ghostview|gv|gxditview|xditview|xdvi)
  4184.         _list_append _rl '-bw' "${_OPT_BW}";
  4185.         ;;
  4186.     esac;
  4187.   fi;
  4188.   if obj _OPT_FG is_not_empty; then
  4189.     case "${_prog}" in
  4190.       ghostview|gv|gxditview|xditview|xdvi)
  4191.         list_append _rl '-fg' "${_OPT_FG}";
  4192.         ;;
  4193.     esac;
  4194.   fi;
  4195.   if is_not_empty "${_OPT_FN}"; then
  4196.     case "${_prog}" in
  4197.       ghostview|gv|gxditview|xditview|xdvi)
  4198.         list_append _rl '-fn' "${_OPT_FN}";
  4199.         ;;
  4200.     esac;
  4201.   fi;
  4202.   if is_not_empty "${_OPT_GEOMETRY}"; then
  4203.     case "${_prog}" in
  4204.       ghostview|gv|gxditview|xditview|xdvi|xpdf)
  4205.         list_append _rl '-geometry' "${_OPT_GEOMETRY}";
  4206.         ;;
  4207.     esac;
  4208.   fi;
  4209.   if is_empty "${_OPT_RESOLUTION}"; then
  4210.     _OPT_RESOLUTION="${_DEFAULT_RESOLUTION}";
  4211.     case "${_prog}" in
  4212.       gxditview|xditview)
  4213.         list_append _rl '-resolution' "${_DEFAULT_RESOLUTION}";
  4214.         ;;
  4215.       xpdf)
  4216.         case "${_DEFAULT_RESOLUTION}" in
  4217.           75)
  4218.             # 72dpi is '100'
  4219.             list_append _rl '-z' '104';
  4220.             ;;
  4221.           100)
  4222.             list_append _rl '-z' '139';
  4223.             ;;
  4224.         esac;
  4225.         ;;
  4226.     esac;
  4227.   else
  4228.     case "${_prog}" in
  4229.       ghostview|gv|gxditview|xditview|xdvi)
  4230.         list_append _rl '-resolution' "${_OPT_RESOLUTION}";
  4231.         ;;
  4232.       xpdf)
  4233.         case "${_OPT_RESOLUTION}" in
  4234.           75)
  4235.             list_append _rl '-z' '104';
  4236.             # '100' corresponds to 72dpi
  4237.             ;;
  4238.           100)
  4239.             list_append _rl '-z' '139';
  4240.             ;;
  4241.         esac;
  4242.         ;;
  4243.     esac;
  4244.   fi;
  4245.   if is_yes "${_OPT_ICONIC}"; then
  4246.     case "${_prog}" in
  4247.       ghostview|gv|gxditview|xditview|xdvi)
  4248.         list_append _rl '-iconic';
  4249.         ;;
  4250.     esac;
  4251.   fi;
  4252.   if is_yes "${_OPT_RV}"; then
  4253.     case "${_prog}" in
  4254.       ghostview|gv|gxditview|xditview|xdvi)
  4255.         list_append _rl '-rv';
  4256.         ;;
  4257.     esac;
  4258.   fi;
  4259.   if is_not_empty "${_OPT_XRM}"; then
  4260.     case "${_prog}" in
  4261.       ghostview|gv|gxditview|xditview|xdvi|xpdf)
  4262.         eval set -- "{$_OPT_XRM}";
  4263.         for i in "$@"; do
  4264.           list_append _rl '-xrm' "$i";
  4265.         done;
  4266.         ;;
  4267.     esac;
  4268.   fi;
  4269.   if is_not_empty "${_title}"; then
  4270.     case "${_prog}" in
  4271.       gxditview|xditview)
  4272.         list_append _rl '-title' "${_title}";
  4273.         ;;
  4274.     esac;
  4275.   fi;
  4276.   _DISPLAY_ARGS="${_rl}"; 
  4277.  
  4278.   eval "${return_ok}";
  4279. } # main_set_resources
  4280.  
  4281.  
  4282. ########################################################################
  4283. # main_display ()
  4284. #
  4285. # Do the actual display of the whole thing.
  4286. #
  4287. # Globals:
  4288. #   in: $_DISPLAY_MODE, $_OPT_DEVICE,
  4289. #       $_ADDOPTS_GROFF, $_ADDOPTS_POST, $_ADDOPTS_X,
  4290. #       $_REGISTERED_TITLE, $_TMP_CAT,
  4291. #       $_OPT_PAGER $PAGER $_MANOPT_PAGER
  4292. #
  4293. landmark '19: main_display()';
  4294. main_display()
  4295. {
  4296.   func_check main_display = 0 "$@";
  4297.   local p;
  4298.   local _addopts;
  4299.   local _device;
  4300.   local _groggy;
  4301.   local _modefile;
  4302.   local _options;
  4303.   local _pager;
  4304.   local _title;
  4305.   export _addopts;
  4306.   export _groggy;
  4307.   export _modefile;
  4308.  
  4309.   if obj _TMP_CAT is_non_empty_file; then
  4310.     _modefile="${_OUTPUT_FILE_NAME}";
  4311.   else
  4312.     clean_up;
  4313.     eval "${return_ok}";
  4314.   fi;
  4315.   case "${_DISPLAY_MODE}" in
  4316.     groff)
  4317.       _ADDOPTS_GROFF="${_ADDOPTS_GROFF} ${_ADDOPTS_POST}";
  4318.       if obj _OPT_DEVICE is_not_empty; then
  4319.         _ADDOPTS_GROFF="${_ADDOPTS_GROFF} -T${_OPT_DEVICE}";
  4320.       fi;
  4321.       _groggy="$(tmp_cat | eval grog "${_options}")";
  4322.       trap_clean;
  4323.       # start a new shell program to get another process ID.
  4324.       sh -c '
  4325.         set -e;
  4326.         test -f "${_modefile}" && rm -f "${_modefile}";
  4327.         mv "${_TMP_CAT}" "${_modefile}";
  4328.         cat "${_modefile}" | \
  4329.         (
  4330.           clean_up()
  4331.           {
  4332.             if test -d "${_TMP_DIR}"; then
  4333.               rm -f "${_TMP_DIR}"/* || true;
  4334.               rmdir "${_TMP_DIR}";
  4335.             fi;
  4336.           }
  4337.           trap clean_up 0 2>/dev/null || true;
  4338.           eval "${_groggy}" "${_ADDOPTS_GROFF}";
  4339.         ) &'
  4340.       ;;
  4341.     text|tty)
  4342.       case "${_OPT_DEVICE}" in
  4343.         '')
  4344.           _device="$(get_first_essential \
  4345.                      "${_OPT_TEXT_DEVICE}" "${_DEFAULT_TTY_DEVICE}")";
  4346.           ;;
  4347.         ascii|cp1047|latin1|utf8)
  4348.           _device="${_OPT_DEVICE}";
  4349.           ;;
  4350.         *)
  4351.           warning \
  4352.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4353.           ;;
  4354.       esac;
  4355.       _addopts="${_ADDOPTS_GROFF} ${_ADDOPTS_POST}";
  4356.       _groggy="$(tmp_cat | grog -T${_device})";
  4357.       if obj _DISPLAY_MODE is_equal 'text'; then
  4358.         tmp_cat | eval "${_groggy}" "${_addopts}";
  4359.       else
  4360.         _pager='';
  4361.         for p in "${_OPT_PAGER}" "${PAGER}" "${_MANOPT_PAGER}" \
  4362.                  'less -r -R' 'more' 'pager' 'cat'; do
  4363.         if is_prog $p; then   # no "" for is_prog() allows args for $p
  4364.           _pager="$p";
  4365.           break;
  4366.         fi;
  4367.         done;
  4368.         if obj _pager is_empty; then
  4369.           error 'no pager program found for tty mode';
  4370.         fi;
  4371.         tmp_cat | eval "${_groggy}" "${_addopts}" | \
  4372.                   eval "${_pager}";
  4373.       fi;
  4374.       clean_up;
  4375.       ;;
  4376.  
  4377.     #### viewer modes
  4378.  
  4379.     dvi)
  4380.       case "${_OPT_DEVICE}" in
  4381.         ''|dvi) do_nothing; ;;
  4382.         *)
  4383.           warning \
  4384.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4385.           ;;
  4386.       esac;
  4387.       _groggy="$(tmp_cat | grog -Tdvi)";
  4388.       _do_display;
  4389.       ;;
  4390.     html)
  4391.       case "${_OPT_DEVICE}" in
  4392.         ''|html) do_nothing; ;;
  4393.         *)
  4394.           warning \
  4395.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4396.           ;;
  4397.       esac;
  4398.       _modefile="${_modefile}".html
  4399.       _groggy="$(tmp_cat | grog -Thtml)";
  4400.       _do_display;
  4401.       ;;
  4402.     pdf)
  4403.       case "${_OPT_DEVICE}" in
  4404.         ''|ps)
  4405.           do_nothing;
  4406.           ;;
  4407.         *)
  4408.           warning \
  4409.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4410.           ;;
  4411.       esac;
  4412.       _modefile="${_modefile}"
  4413.       _groggy="$(tmp_cat | grog -Tps)";
  4414.       trap_clean;
  4415.       # start a new shell program to get another process ID.
  4416.       sh -c '
  4417.         set -e;
  4418.         _psfile="${_modefile}.ps";
  4419.         _modefile="${_modefile}.pdf";
  4420.         test -f "${_psfile}" && rm -f "${_psfile}";
  4421.         test -f "${_modefile}" && rm -f "${_modefile}";
  4422.         cat "${_TMP_CAT}" | \
  4423.           eval "${_groggy}" "${_ADDOPTS_GROFF}" > "${_psfile}";
  4424.         gs -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite \
  4425.            -sOutputFile="${_modefile}" -c save pop -f "${_psfile}";
  4426.         test -f "${_psfile}" && rm -f "${_psfile}";
  4427.         test -f "${_TMP_CAT}" && rm -f "${_TMP_CAT}";
  4428.         (
  4429.           clean_up() {
  4430.             rm -f "${_modefile}";
  4431.             if test -d "${_TMP_DIR}"; then
  4432.               rm -f "${_TMP_DIR}"/* || true;
  4433.               rmdir "${_TMP_DIR}";
  4434.             fi;
  4435.           }
  4436.           trap clean_up 0 2>/dev/null || true;
  4437.           eval "${_DISPLAY_PROG}" ${_DISPLAY_ARGS} "${_modefile}";
  4438.         ) &'
  4439.       ;;
  4440.     ps)
  4441.       case "${_OPT_DEVICE}" in
  4442.         ''|ps)
  4443.           do_nothing;
  4444.           ;;
  4445.         *)
  4446.           warning \
  4447.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4448.           ;;
  4449.       esac;
  4450.       _groggy="$(tmp_cat | grog -Tps)";
  4451.       _do_display;
  4452.       ;;
  4453.     source)
  4454.       tmp_cat;
  4455.       clean_up;
  4456.       ;;
  4457.     x)
  4458.       case "${_OPT_DEVICE}" in
  4459.         '')
  4460.           _groggy="$(tmp_cat | grog -Z)";
  4461.           ;;
  4462.         X*|ps)
  4463.           _groggy="$(tmp_cat | grog -T"${_OPT_DEVICE}" -Z)";
  4464.           ;;
  4465.         *)
  4466.           warning \
  4467.             "wrong device for ${_DISPLAY_MODE} mode: ${_OPT_DEVICE}";
  4468.           _groggy="$(tmp_cat | grog -Z)";
  4469.           ;;
  4470.       esac;
  4471.       _do_display;
  4472.       ;;
  4473.     *)
  4474.       error "unknown mode \`${_DISPLAY_MODE}'";
  4475.       ;;
  4476.   esac;
  4477.   eval "${return_ok}";
  4478. } # main_display()
  4479.  
  4480. _do_display()
  4481. {
  4482.   func_check _do_display = 0 "$@";
  4483.   trap_clean;
  4484.   # start a new shell program for another process ID and better
  4485.   # cleaning-up of the temporary files.
  4486.   sh -c '
  4487.     set -e;
  4488.     test -f "${_modefile}" && rm -f "${_modefile}";
  4489.     cat "${_TMP_CAT}" | \
  4490.       eval "${_groggy}" "${_ADDOPTS_GROFF}" > "${_modefile}";
  4491.     rm -f "${_TMP_CAT}";
  4492.     (
  4493.       clean_up() {
  4494.         if test -d "${_TMP_DIR}"; then
  4495.           rm -f "${_TMP_DIR}"/* || true;
  4496.           rmdir "${_TMP_DIR}";
  4497.         fi;
  4498.       }
  4499.       trap clean_up 0 2>/dev/null || true;
  4500.       eval "${_DISPLAY_PROG}" ${_DISPLAY_ARGS} "${_modefile}";
  4501.     ) &'
  4502. }
  4503.  
  4504.  
  4505. ########################################################################
  4506. # main (<command_line_args>*)
  4507. #
  4508. # The main function for groffer.
  4509. #
  4510. # Arguments:
  4511. #
  4512. main()
  4513. {
  4514.   func_check main '>=' 0 "$@";
  4515.   # Do not change the sequence of the following functions!
  4516.   main_init;
  4517.   main_parse_MANOPT;
  4518.   main_parse_args "$@";
  4519.   main_set_mode;
  4520.   main_do_fileargs;
  4521.   main_set_resources;
  4522.   main_display;
  4523.   eval "${return_ok}";
  4524. }
  4525.  
  4526. landmark '20: end of function definitions';
  4527.  
  4528. ########################################################################
  4529.  
  4530. main "$@";
  4531.